3.19-stable patches

added patches:
	clockevents-sun5i-fix-setup_irq-init-sequence.patch
	clocksource-efm32-fix-a-null-pointer-dereference.patch
	regmap-introduce-regmap_name-to-fix-syscon-regmap-trace-events.patch
	regmap-regcache-rbtree-fix-present-bitmap-resize.patch
	tcm_fc-missing-curly-braces-in-ft_invl_hw_context.patch
	tcm_qla2xxx-fix-incorrect-use-of-__transport_register_session.patch
	virtio-balloon-do-not-call-blocking-ops-when-task_running.patch
	virtio_balloon-set-driver_ok-before-using-device.patch

diff --git a/queue-3.19/clockevents-sun5i-fix-setup_irq-init-sequence.patch b/queue-3.19/clockevents-sun5i-fix-setup_irq-init-sequence.patch
new file mode 100644 (file)
index 0000000..40c2d8c
--- /dev/null
+++ b/queue-3.19/clockevents-sun5i-fix-setup_irq-init-sequence.patch
@@ -0,0 +1,48 @@
+From 1096be084ac59927158ce80ff1d31c33eed0e565 Mon Sep 17 00:00:00 2001
+From: Yongbae Park <yongbae2@gmail.com>
+Date: Tue, 3 Mar 2015 13:05:48 +0900
+Subject: clockevents: sun5i: Fix setup_irq init sequence
+
+From: Yongbae Park <yongbae2@gmail.com>
+
+commit 1096be084ac59927158ce80ff1d31c33eed0e565 upstream.
+
+The interrupt is enabled before the handler is set. Even this bug
+did not appear, it is potentially dangerous as it can lead to a
+NULL pointer dereference.
+
+Fix the error by enabling the interrupt after
+clockevents_config_and_register() is called.
+
+Signed-off-by: Yongbae Park <yongbae2@gmail.com>
+Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+---
+ drivers/clocksource/timer-sun5i.c |    8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+--- a/drivers/clocksource/timer-sun5i.c
++++ b/drivers/clocksource/timer-sun5i.c
+@@ -178,10 +178,6 @@ static void __init sun5i_timer_init(stru
+ 
+       ticks_per_jiffy = DIV_ROUND_UP(rate, HZ);
+ 
+-      ret = setup_irq(irq, &sun5i_timer_irq);
+-      if (ret)
+-              pr_warn("failed to setup irq %d\n", irq);
+-
+       /* Enable timer0 interrupt */
+       val = readl(timer_base + TIMER_IRQ_EN_REG);
+       writel(val | TIMER_IRQ_EN(0), timer_base + TIMER_IRQ_EN_REG);
+@@ -191,6 +187,10 @@ static void __init sun5i_timer_init(stru
+ 
+       clockevents_config_and_register(&sun5i_clockevent, rate,
+                                       TIMER_SYNC_TICKS, 0xffffffff);
++
++      ret = setup_irq(irq, &sun5i_timer_irq);
++      if (ret)
++              pr_warn("failed to setup irq %d\n", irq);
+ }
+ CLOCKSOURCE_OF_DECLARE(sun5i_a13, "allwinner,sun5i-a13-hstimer",
+                      sun5i_timer_init);

diff --git a/queue-3.19/clocksource-efm32-fix-a-null-pointer-dereference.patch b/queue-3.19/clocksource-efm32-fix-a-null-pointer-dereference.patch
new file mode 100644 (file)
index 0000000..8166916
--- /dev/null
+++ b/queue-3.19/clocksource-efm32-fix-a-null-pointer-dereference.patch
@@ -0,0 +1,46 @@
+From 7b8f10da3bf1056546133c9f54f49ce389fd95ab Mon Sep 17 00:00:00 2001
+From: Yongbae Park <yongbae2@gmail.com>
+Date: Tue, 3 Mar 2015 19:46:49 +0900
+Subject: clocksource: efm32: Fix a NULL pointer dereference
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+From: Yongbae Park <yongbae2@gmail.com>
+
+commit 7b8f10da3bf1056546133c9f54f49ce389fd95ab upstream.
+
+The initialisation of the efm32 clocksource first sets up the irq and only
+after that initialises the data needed for irq handling. In case this
+initialisation is delayed the irq handler would dereference a NULL pointer.
+
+I'm not aware of anything that could delay the process in such a way, but it's
+better to be safe than sorry, so setup the irq only when the clock event device
+is ready.
+
+Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
+Signed-off-by: Yongbae Park <yongbae2@gmail.com>
+Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+---
+ drivers/clocksource/time-efm32.c |    4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+--- a/drivers/clocksource/time-efm32.c
++++ b/drivers/clocksource/time-efm32.c
+@@ -225,12 +225,12 @@ static int __init efm32_clockevent_init(
+       clock_event_ddata.base = base;
+       clock_event_ddata.periodic_top = DIV_ROUND_CLOSEST(rate, 1024 * HZ);
+ 
+-      setup_irq(irq, &efm32_clock_event_irq);
+-
+       clockevents_config_and_register(&clock_event_ddata.evtdev,
+                                       DIV_ROUND_CLOSEST(rate, 1024),
+                                       0xf, 0xffff);
+ 
++      setup_irq(irq, &efm32_clock_event_irq);
++
+       return 0;
+ 
+ err_get_irq:

diff --git a/queue-3.19/regmap-introduce-regmap_name-to-fix-syscon-regmap-trace-events.patch b/queue-3.19/regmap-introduce-regmap_name-to-fix-syscon-regmap-trace-events.patch
new file mode 100644 (file)
index 0000000..c852c8b
--- /dev/null
+++ b/queue-3.19/regmap-introduce-regmap_name-to-fix-syscon-regmap-trace-events.patch
@@ -0,0 +1,605 @@
+From c6b570d97c0e77f570bb6b2ed30d372b2b1e9aae Mon Sep 17 00:00:00 2001
+From: Philipp Zabel <p.zabel@pengutronix.de>
+Date: Mon, 9 Mar 2015 12:20:13 +0100
+Subject: regmap: introduce regmap_name to fix syscon regmap trace events
+
+From: Philipp Zabel <p.zabel@pengutronix.de>
+
+commit c6b570d97c0e77f570bb6b2ed30d372b2b1e9aae upstream.
+
+This patch fixes a NULL pointer dereference when enabling regmap event
+tracing in the presence of a syscon regmap, introduced by commit bdb0066df96e
+("mfd: syscon: Decouple syscon interface from platform devices").
+That patch introduced syscon regmaps that have their dev field set to NULL.
+The regmap trace events expect it to point to a valid struct device and feed
+it to dev_name():
+
+  $ echo 1 > /sys/kernel/debug/tracing/events/regmap/enable
+
+  Unable to handle kernel NULL pointer dereference at virtual address 0000002c
+  pgd = 80004000
+  [0000002c] *pgd=00000000
+  Internal error: Oops: 17 [#1] SMP ARM
+  Modules linked in: coda videobuf2_vmalloc
+  CPU: 0 PID: 304 Comm: kworker/0:2 Not tainted 4.0.0-rc2+ #9197
+  Hardware name: Freescale i.MX6 Quad/DualLite (Device Tree)
+  Workqueue: events_freezable thermal_zone_device_check
+  task: 9f25a200 ti: 9f1ee000 task.ti: 9f1ee000
+  PC is at ftrace_raw_event_regmap_block+0x3c/0xe4
+  LR is at _regmap_raw_read+0x1bc/0x1cc
+  pc : [<803636e8>]    lr : [<80365f2c>]    psr: 600f0093
+  sp : 9f1efd78  ip : 9f1efdb8  fp : 9f1efdb4
+  r10: 00000004  r9 : 00000001  r8 : 00000001
+  r7 : 00000180  r6 : 00000000  r5 : 9f00e3c0  r4 : 00000003
+  r3 : 00000001  r2 : 00000180  r1 : 00000000  r0 : 9f00e3c0
+  Flags: nZCv  IRQs off  FIQs on  Mode SVC_32  ISA ARM  Segment kernel
+  Control: 10c5387d  Table: 2d91004a  DAC: 00000015
+  Process kworker/0:2 (pid: 304, stack limit = 0x9f1ee210)
+  Stack: (0x9f1efd78 to 0x9f1f0000)
+  fd60:                                                       9f1efda4 9f1efd88
+  fd80: 800708c0 805f9510 80927140 800f0013 9f1fc800 9eb2f490 00000000 00000180
+  fda0: 808e3840 00000001 9f1efdfc 9f1efdb8 80365f2c 803636b8 805f8958 800708e0
+  fdc0: a00f0013 803636ac 9f16de00 00000180 80927140 9f1fc800 9f1fc800 9f1efe6c
+  fde0: 9f1efe6c 9f732400 00000000 00000000 9f1efe1c 9f1efe00 80365f70 80365d7c
+  fe00: 80365f3c 9f1fc800 9f1fc800 00000180 9f1efe44 9f1efe20 803656a4 80365f48
+  fe20: 9f1fc800 00000180 9f1efe6c 9f1efe6c 9f732400 00000000 9f1efe64 9f1efe48
+  fe40: 803657bc 80365634 00000001 9e95f910 9f1fc800 9f1efeb4 9f1efe8c 9f1efe68
+  fe60: 80452ac0 80365778 9f1efe8c 9f1efe78 9e93d400 9e93d5e8 9f1efeb4 9f72ef40
+  fe80: 9f1efeac 9f1efe90 8044e11c 80452998 8045298c 9e93d608 9e93d400 808e1978
+  fea0: 9f1efecc 9f1efeb0 8044fd14 8044e0d0 ffffffff 9f25a200 9e93d608 9e481380
+  fec0: 9f1efedc 9f1efed0 8044fde8 8044fcec 9f1eff1c 9f1efee0 80038d50 8044fdd8
+  fee0: 9f1ee020 9f72ef40 9e481398 00000000 00000008 9f72ef54 9f1ee020 9f72ef40
+  ff00: 9e481398 9e481380 00000008 9f72ef40 9f1eff5c 9f1eff20 80039754 80038bfc
+  ff20: 00000000 9e481380 80894100 808e1662 00000000 9e4f2ec0 00000000 9e481380
+  ff40: 800396f8 00000000 00000000 00000000 9f1effac 9f1eff60 8003e020 80039704
+  ff60: ffffffff 00000000 ffffffff 9e481380 00000000 00000000 9f1eff78 9f1eff78
+  ff80: 00000000 00000000 9f1eff88 9f1eff88 9e4f2ec0 8003df30 00000000 00000000
+  ffa0: 00000000 9f1effb0 8000eb60 8003df3c 00000000 00000000 00000000 00000000
+  ffc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
+  ffe0: 00000000 00000000 00000000 00000000 00000013 00000000 ffffffff ffffffff
+  Backtrace:
+  [<803636ac>] (ftrace_raw_event_regmap_block) from [<80365f2c>] (_regmap_raw_read+0x1bc/0x1cc)
+   r9:00000001 r8:808e3840 r7:00000180 r6:00000000 r5:9eb2f490 r4:9f1fc800
+  [<80365d70>] (_regmap_raw_read) from [<80365f70>] (_regmap_bus_read+0x34/0x6c)
+   r10:00000000 r9:00000000 r8:9f732400 r7:9f1efe6c r6:9f1efe6c r5:9f1fc800
+   r4:9f1fc800
+  [<80365f3c>] (_regmap_bus_read) from [<803656a4>] (_regmap_read+0x7c/0x144)
+   r6:00000180 r5:9f1fc800 r4:9f1fc800 r3:80365f3c
+  [<80365628>] (_regmap_read) from [<803657bc>] (regmap_read+0x50/0x70)
+   r9:00000000 r8:9f732400 r7:9f1efe6c r6:9f1efe6c r5:00000180 r4:9f1fc800
+  [<8036576c>] (regmap_read) from [<80452ac0>] (imx_get_temp+0x134/0x1a4)
+   r6:9f1efeb4 r5:9f1fc800 r4:9e95f910 r3:00000001
+  [<8045298c>] (imx_get_temp) from [<8044e11c>] (thermal_zone_get_temp+0x58/0x74)
+   r7:9f72ef40 r6:9f1efeb4 r5:9e93d5e8 r4:9e93d400
+  [<8044e0c4>] (thermal_zone_get_temp) from [<8044fd14>] (thermal_zone_device_update+0x34/0xec)
+   r6:808e1978 r5:9e93d400 r4:9e93d608 r3:8045298c
+  [<8044fce0>] (thermal_zone_device_update) from [<8044fde8>] (thermal_zone_device_check+0x1c/0x20)
+   r5:9e481380 r4:9e93d608
+  [<8044fdcc>] (thermal_zone_device_check) from [<80038d50>] (process_one_work+0x160/0x3d4)
+  [<80038bf0>] (process_one_work) from [<80039754>] (worker_thread+0x5c/0x4f4)
+   r10:9f72ef40 r9:00000008 r8:9e481380 r7:9e481398 r6:9f72ef40 r5:9f1ee020
+   r4:9f72ef54
+  [<800396f8>] (worker_thread) from [<8003e020>] (kthread+0xf0/0x108)
+   r10:00000000 r9:00000000 r8:00000000 r7:800396f8 r6:9e481380 r5:00000000
+   r4:9e4f2ec0
+  [<8003df30>] (kthread) from [<8000eb60>] (ret_from_fork+0x14/0x34)
+   r7:00000000 r6:00000000 r5:8003df30 r4:9e4f2ec0
+  Code: e3140040 1a00001a e3140020 1a000016 (e596002c)
+  ---[ end trace 193c15c2494ec960 ]---
+
+Fixes: bdb0066df96e (mfd: syscon: Decouple syscon interface from platform devices)
+Signed-off-by: Philipp Zabel <p.zabel@pengutronix.de>
+Signed-off-by: Mark Brown <broonie@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+---
+ drivers/base/regmap/internal.h |    8 ++
+ drivers/base/regmap/regcache.c |   16 ++---
+ drivers/base/regmap/regmap.c   |   32 ++++------
+ include/trace/events/regmap.h  |  123 ++++++++++++++++++++---------------------
+ 4 files changed, 91 insertions(+), 88 deletions(-)
+
+--- a/drivers/base/regmap/internal.h
++++ b/drivers/base/regmap/internal.h
+@@ -237,4 +237,12 @@ extern struct regcache_ops regcache_rbtr
+ extern struct regcache_ops regcache_lzo_ops;
+ extern struct regcache_ops regcache_flat_ops;
+ 
++static inline const char *regmap_name(const struct regmap *map)
++{
++      if (map->dev)
++              return dev_name(map->dev);
++
++      return map->name;
++}
++
+ #endif
+--- a/drivers/base/regmap/regcache.c
++++ b/drivers/base/regmap/regcache.c
+@@ -218,7 +218,7 @@ int regcache_read(struct regmap *map,
+               ret = map->cache_ops->read(map, reg, value);
+ 
+               if (ret == 0)
+-                      trace_regmap_reg_read_cache(map->dev, reg, *value);
++                      trace_regmap_reg_read_cache(map, reg, *value);
+ 
+               return ret;
+       }
+@@ -311,7 +311,7 @@ int regcache_sync(struct regmap *map)
+       dev_dbg(map->dev, "Syncing %s cache\n",
+               map->cache_ops->name);
+       name = map->cache_ops->name;
+-      trace_regcache_sync(map->dev, name, "start");
++      trace_regcache_sync(map, name, "start");
+ 
+       if (!map->cache_dirty)
+               goto out;
+@@ -346,7 +346,7 @@ out:
+ 
+       regmap_async_complete(map);
+ 
+-      trace_regcache_sync(map->dev, name, "stop");
++      trace_regcache_sync(map, name, "stop");
+ 
+       return ret;
+ }
+@@ -381,7 +381,7 @@ int regcache_sync_region(struct regmap *
+       name = map->cache_ops->name;
+       dev_dbg(map->dev, "Syncing %s cache from %d-%d\n", name, min, max);
+ 
+-      trace_regcache_sync(map->dev, name, "start region");
++      trace_regcache_sync(map, name, "start region");
+ 
+       if (!map->cache_dirty)
+               goto out;
+@@ -401,7 +401,7 @@ out:
+ 
+       regmap_async_complete(map);
+ 
+-      trace_regcache_sync(map->dev, name, "stop region");
++      trace_regcache_sync(map, name, "stop region");
+ 
+       return ret;
+ }
+@@ -428,7 +428,7 @@ int regcache_drop_region(struct regmap *
+ 
+       map->lock(map->lock_arg);
+ 
+-      trace_regcache_drop_region(map->dev, min, max);
++      trace_regcache_drop_region(map, min, max);
+ 
+       ret = map->cache_ops->drop(map, min, max);
+ 
+@@ -455,7 +455,7 @@ void regcache_cache_only(struct regmap *
+       map->lock(map->lock_arg);
+       WARN_ON(map->cache_bypass && enable);
+       map->cache_only = enable;
+-      trace_regmap_cache_only(map->dev, enable);
++      trace_regmap_cache_only(map, enable);
+       map->unlock(map->lock_arg);
+ }
+ EXPORT_SYMBOL_GPL(regcache_cache_only);
+@@ -493,7 +493,7 @@ void regcache_cache_bypass(struct regmap
+       map->lock(map->lock_arg);
+       WARN_ON(map->cache_only && enable);
+       map->cache_bypass = enable;
+-      trace_regmap_cache_bypass(map->dev, enable);
++      trace_regmap_cache_bypass(map, enable);
+       map->unlock(map->lock_arg);
+ }
+ EXPORT_SYMBOL_GPL(regcache_cache_bypass);
+--- a/drivers/base/regmap/regmap.c
++++ b/drivers/base/regmap/regmap.c
+@@ -1280,7 +1280,7 @@ int _regmap_raw_write(struct regmap *map
+       if (map->async && map->bus->async_write) {
+               struct regmap_async *async;
+ 
+-              trace_regmap_async_write_start(map->dev, reg, val_len);
++              trace_regmap_async_write_start(map, reg, val_len);
+ 
+               spin_lock_irqsave(&map->async_lock, flags);
+               async = list_first_entry_or_null(&map->async_free,
+@@ -1338,8 +1338,7 @@ int _regmap_raw_write(struct regmap *map
+               return ret;
+       }
+ 
+-      trace_regmap_hw_write_start(map->dev, reg,
+-                                  val_len / map->format.val_bytes);
++      trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
+ 
+       /* If we're doing a single register write we can probably just
+        * send the work_buf directly, otherwise try to do a gather
+@@ -1371,8 +1370,7 @@ int _regmap_raw_write(struct regmap *map
+               kfree(buf);
+       }
+ 
+-      trace_regmap_hw_write_done(map->dev, reg,
+-                                 val_len / map->format.val_bytes);
++      trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
+ 
+       return ret;
+ }
+@@ -1406,12 +1404,12 @@ static int _regmap_bus_formatted_write(v
+ 
+       map->format.format_write(map, reg, val);
+ 
+-      trace_regmap_hw_write_start(map->dev, reg, 1);
++      trace_regmap_hw_write_start(map, reg, 1);
+ 
+       ret = map->bus->write(map->bus_context, map->work_buf,
+                             map->format.buf_size);
+ 
+-      trace_regmap_hw_write_done(map->dev, reg, 1);
++      trace_regmap_hw_write_done(map, reg, 1);
+ 
+       return ret;
+ }
+@@ -1469,7 +1467,7 @@ int _regmap_write(struct regmap *map, un
+               dev_info(map->dev, "%x <= %x\n", reg, val);
+ #endif
+ 
+-      trace_regmap_reg_write(map->dev, reg, val);
++      trace_regmap_reg_write(map, reg, val);
+ 
+       return map->reg_write(context, reg, val);
+ }
+@@ -1772,7 +1770,7 @@ static int _regmap_raw_multi_reg_write(s
+       for (i = 0; i < num_regs; i++) {
+               int reg = regs[i].reg;
+               int val = regs[i].def;
+-              trace_regmap_hw_write_start(map->dev, reg, 1);
++              trace_regmap_hw_write_start(map, reg, 1);
+               map->format.format_reg(u8, reg, map->reg_shift);
+               u8 += reg_bytes + pad_bytes;
+               map->format.format_val(u8, val, 0);
+@@ -1787,7 +1785,7 @@ static int _regmap_raw_multi_reg_write(s
+ 
+       for (i = 0; i < num_regs; i++) {
+               int reg = regs[i].reg;
+-              trace_regmap_hw_write_done(map->dev, reg, 1);
++              trace_regmap_hw_write_done(map, reg, 1);
+       }
+       return ret;
+ }
+@@ -2058,15 +2056,13 @@ static int _regmap_raw_read(struct regma
+        */
+       u8[0] |= map->read_flag_mask;
+ 
+-      trace_regmap_hw_read_start(map->dev, reg,
+-                                 val_len / map->format.val_bytes);
++      trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
+ 
+       ret = map->bus->read(map->bus_context, map->work_buf,
+                            map->format.reg_bytes + map->format.pad_bytes,
+                            val, val_len);
+ 
+-      trace_regmap_hw_read_done(map->dev, reg,
+-                                val_len / map->format.val_bytes);
++      trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
+ 
+       return ret;
+ }
+@@ -2122,7 +2118,7 @@ static int _regmap_read(struct regmap *m
+                       dev_info(map->dev, "%x => %x\n", reg, *val);
+ #endif
+ 
+-              trace_regmap_reg_read(map->dev, reg, *val);
++              trace_regmap_reg_read(map, reg, *val);
+ 
+               if (!map->cache_bypass)
+                       regcache_write(map, reg, *val);
+@@ -2479,7 +2475,7 @@ void regmap_async_complete_cb(struct reg
+       struct regmap *map = async->map;
+       bool wake;
+ 
+-      trace_regmap_async_io_complete(map->dev);
++      trace_regmap_async_io_complete(map);
+ 
+       spin_lock(&map->async_lock);
+       list_move(&async->list, &map->async_free);
+@@ -2524,7 +2520,7 @@ int regmap_async_complete(struct regmap
+       if (!map->bus || !map->bus->async_write)
+               return 0;
+ 
+-      trace_regmap_async_complete_start(map->dev);
++      trace_regmap_async_complete_start(map);
+ 
+       wait_event(map->async_waitq, regmap_async_is_done(map));
+ 
+@@ -2533,7 +2529,7 @@ int regmap_async_complete(struct regmap
+       map->async_ret = 0;
+       spin_unlock_irqrestore(&map->async_lock, flags);
+ 
+-      trace_regmap_async_complete_done(map->dev);
++      trace_regmap_async_complete_done(map);
+ 
+       return ret;
+ }
+--- a/include/trace/events/regmap.h
++++ b/include/trace/events/regmap.h
+@@ -7,27 +7,26 @@
+ #include <linux/ktime.h>
+ #include <linux/tracepoint.h>
+ 
+-struct device;
+-struct regmap;
++#include "../../../drivers/base/regmap/internal.h"
+ 
+ /*
+  * Log register events
+  */
+ DECLARE_EVENT_CLASS(regmap_reg,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg,
++      TP_PROTO(struct regmap *map, unsigned int reg,
+                unsigned int val),
+ 
+-      TP_ARGS(dev, reg, val),
++      TP_ARGS(map, reg, val),
+ 
+       TP_STRUCT__entry(
+-              __string(       name,           dev_name(dev)   )
+-              __field(        unsigned int,   reg             )
+-              __field(        unsigned int,   val             )
++              __string(       name,           regmap_name(map)        )
++              __field(        unsigned int,   reg                     )
++              __field(        unsigned int,   val                     )
+       ),
+ 
+       TP_fast_assign(
+-              __assign_str(name, dev_name(dev));
++              __assign_str(name, regmap_name(map));
+               __entry->reg = reg;
+               __entry->val = val;
+       ),
+@@ -39,45 +38,45 @@ DECLARE_EVENT_CLASS(regmap_reg,
+ 
+ DEFINE_EVENT(regmap_reg, regmap_reg_write,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg,
++      TP_PROTO(struct regmap *map, unsigned int reg,
+                unsigned int val),
+ 
+-      TP_ARGS(dev, reg, val)
++      TP_ARGS(map, reg, val)
+ 
+ );
+ 
+ DEFINE_EVENT(regmap_reg, regmap_reg_read,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg,
++      TP_PROTO(struct regmap *map, unsigned int reg,
+                unsigned int val),
+ 
+-      TP_ARGS(dev, reg, val)
++      TP_ARGS(map, reg, val)
+ 
+ );
+ 
+ DEFINE_EVENT(regmap_reg, regmap_reg_read_cache,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg,
++      TP_PROTO(struct regmap *map, unsigned int reg,
+                unsigned int val),
+ 
+-      TP_ARGS(dev, reg, val)
++      TP_ARGS(map, reg, val)
+ 
+ );
+ 
+ DECLARE_EVENT_CLASS(regmap_block,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg, int count),
++      TP_PROTO(struct regmap *map, unsigned int reg, int count),
+ 
+-      TP_ARGS(dev, reg, count),
++      TP_ARGS(map, reg, count),
+ 
+       TP_STRUCT__entry(
+-              __string(       name,           dev_name(dev)   )
+-              __field(        unsigned int,   reg             )
+-              __field(        int,            count           )
++              __string(       name,           regmap_name(map)        )
++              __field(        unsigned int,   reg                     )
++              __field(        int,            count                   )
+       ),
+ 
+       TP_fast_assign(
+-              __assign_str(name, dev_name(dev));
++              __assign_str(name, regmap_name(map));
+               __entry->reg = reg;
+               __entry->count = count;
+       ),
+@@ -89,48 +88,48 @@ DECLARE_EVENT_CLASS(regmap_block,
+ 
+ DEFINE_EVENT(regmap_block, regmap_hw_read_start,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg, int count),
++      TP_PROTO(struct regmap *map, unsigned int reg, int count),
+ 
+-      TP_ARGS(dev, reg, count)
++      TP_ARGS(map, reg, count)
+ );
+ 
+ DEFINE_EVENT(regmap_block, regmap_hw_read_done,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg, int count),
++      TP_PROTO(struct regmap *map, unsigned int reg, int count),
+ 
+-      TP_ARGS(dev, reg, count)
++      TP_ARGS(map, reg, count)
+ );
+ 
+ DEFINE_EVENT(regmap_block, regmap_hw_write_start,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg, int count),
++      TP_PROTO(struct regmap *map, unsigned int reg, int count),
+ 
+-      TP_ARGS(dev, reg, count)
++      TP_ARGS(map, reg, count)
+ );
+ 
+ DEFINE_EVENT(regmap_block, regmap_hw_write_done,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg, int count),
++      TP_PROTO(struct regmap *map, unsigned int reg, int count),
+ 
+-      TP_ARGS(dev, reg, count)
++      TP_ARGS(map, reg, count)
+ );
+ 
+ TRACE_EVENT(regcache_sync,
+ 
+-      TP_PROTO(struct device *dev, const char *type,
++      TP_PROTO(struct regmap *map, const char *type,
+                const char *status),
+ 
+-      TP_ARGS(dev, type, status),
++      TP_ARGS(map, type, status),
+ 
+       TP_STRUCT__entry(
+-              __string(       name,           dev_name(dev)   )
+-              __string(       status,         status          )
+-              __string(       type,           type            )
+-              __field(        int,            type            )
++              __string(       name,           regmap_name(map)        )
++              __string(       status,         status                  )
++              __string(       type,           type                    )
++              __field(        int,            type                    )
+       ),
+ 
+       TP_fast_assign(
+-              __assign_str(name, dev_name(dev));
++              __assign_str(name, regmap_name(map));
+               __assign_str(status, status);
+               __assign_str(type, type);
+       ),
+@@ -141,17 +140,17 @@ TRACE_EVENT(regcache_sync,
+ 
+ DECLARE_EVENT_CLASS(regmap_bool,
+ 
+-      TP_PROTO(struct device *dev, bool flag),
++      TP_PROTO(struct regmap *map, bool flag),
+ 
+-      TP_ARGS(dev, flag),
++      TP_ARGS(map, flag),
+ 
+       TP_STRUCT__entry(
+-              __string(       name,           dev_name(dev)   )
+-              __field(        int,            flag            )
++              __string(       name,           regmap_name(map)        )
++              __field(        int,            flag                    )
+       ),
+ 
+       TP_fast_assign(
+-              __assign_str(name, dev_name(dev));
++              __assign_str(name, regmap_name(map));
+               __entry->flag = flag;
+       ),
+ 
+@@ -161,32 +160,32 @@ DECLARE_EVENT_CLASS(regmap_bool,
+ 
+ DEFINE_EVENT(regmap_bool, regmap_cache_only,
+ 
+-      TP_PROTO(struct device *dev, bool flag),
++      TP_PROTO(struct regmap *map, bool flag),
+ 
+-      TP_ARGS(dev, flag)
++      TP_ARGS(map, flag)
+ 
+ );
+ 
+ DEFINE_EVENT(regmap_bool, regmap_cache_bypass,
+ 
+-      TP_PROTO(struct device *dev, bool flag),
++      TP_PROTO(struct regmap *map, bool flag),
+ 
+-      TP_ARGS(dev, flag)
++      TP_ARGS(map, flag)
+ 
+ );
+ 
+ DECLARE_EVENT_CLASS(regmap_async,
+ 
+-      TP_PROTO(struct device *dev),
++      TP_PROTO(struct regmap *map),
+ 
+-      TP_ARGS(dev),
++      TP_ARGS(map),
+ 
+       TP_STRUCT__entry(
+-              __string(       name,           dev_name(dev)   )
++              __string(       name,           regmap_name(map)        )
+       ),
+ 
+       TP_fast_assign(
+-              __assign_str(name, dev_name(dev));
++              __assign_str(name, regmap_name(map));
+       ),
+ 
+       TP_printk("%s", __get_str(name))
+@@ -194,50 +193,50 @@ DECLARE_EVENT_CLASS(regmap_async,
+ 
+ DEFINE_EVENT(regmap_block, regmap_async_write_start,
+ 
+-      TP_PROTO(struct device *dev, unsigned int reg, int count),
++      TP_PROTO(struct regmap *map, unsigned int reg, int count),
+ 
+-      TP_ARGS(dev, reg, count)
++      TP_ARGS(map, reg, count)
+ );
+ 
+ DEFINE_EVENT(regmap_async, regmap_async_io_complete,
+ 
+-      TP_PROTO(struct device *dev),
++      TP_PROTO(struct regmap *map),
+ 
+-      TP_ARGS(dev)
++      TP_ARGS(map)
+ 
+ );
+ 
+ DEFINE_EVENT(regmap_async, regmap_async_complete_start,
+ 
+-      TP_PROTO(struct device *dev),
++      TP_PROTO(struct regmap *map),
+ 
+-      TP_ARGS(dev)
++      TP_ARGS(map)
+ 
+ );
+ 
+ DEFINE_EVENT(regmap_async, regmap_async_complete_done,
+ 
+-      TP_PROTO(struct device *dev),
++      TP_PROTO(struct regmap *map),
+ 
+-      TP_ARGS(dev)
++      TP_ARGS(map)
+ 
+ );
+ 
+ TRACE_EVENT(regcache_drop_region,
+ 
+-      TP_PROTO(struct device *dev, unsigned int from,
++      TP_PROTO(struct regmap *map, unsigned int from,
+                unsigned int to),
+ 
+-      TP_ARGS(dev, from, to),
++      TP_ARGS(map, from, to),
+ 
+       TP_STRUCT__entry(
+-              __string(       name,           dev_name(dev)   )
+-              __field(        unsigned int,   from            )
+-              __field(        unsigned int,   to              )
++              __string(       name,           regmap_name(map)        )
++              __field(        unsigned int,   from                    )
++              __field(        unsigned int,   to                      )
+       ),
+ 
+       TP_fast_assign(
+-              __assign_str(name, dev_name(dev));
++              __assign_str(name, regmap_name(map));
+               __entry->from = from;
+               __entry->to = to;
+       ),

diff --git a/queue-3.19/regmap-regcache-rbtree-fix-present-bitmap-resize.patch b/queue-3.19/regmap-regcache-rbtree-fix-present-bitmap-resize.patch
new file mode 100644 (file)
index 0000000..142945c
--- /dev/null
+++ b/queue-3.19/regmap-regcache-rbtree-fix-present-bitmap-resize.patch
@@ -0,0 +1,37 @@
+From 328f494d95aac8bd4896aea2328bc281053bcb71 Mon Sep 17 00:00:00 2001
+From: Lars-Peter Clausen <lars@metafoo.de>
+Date: Sat, 7 Mar 2015 17:10:01 +0100
+Subject: regmap: regcache-rbtree: Fix present bitmap resize
+
+From: Lars-Peter Clausen <lars@metafoo.de>
+
+commit 328f494d95aac8bd4896aea2328bc281053bcb71 upstream.
+
+When inserting a new register into a block at the lower end the present
+bitmap is currently shifted into the wrong direction. The effect of this is
+that the bitmap becomes corrupted and registers which are present might be
+reported as not present and vice versa.
+
+Fix this by shifting left rather than right.
+
+Fixes: 472fdec7380c("regmap: rbtree: Reduce number of nodes, take 2")
+Reported-by: Daniel Baluta <daniel.baluta@gmail.com>
+Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
+Signed-off-by: Mark Brown <broonie@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+---
+ drivers/base/regmap/regcache-rbtree.c |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/drivers/base/regmap/regcache-rbtree.c
++++ b/drivers/base/regmap/regcache-rbtree.c
+@@ -307,7 +307,7 @@ static int regcache_rbtree_insert_to_blo
+       if (pos == 0) {
+               memmove(blk + offset * map->cache_word_size,
+                       blk, rbnode->blklen * map->cache_word_size);
+-              bitmap_shift_right(present, present, offset, blklen);
++              bitmap_shift_left(present, present, offset, blklen);
+       }
+ 
+       /* update the rbnode block, its size and the base register */

diff --git a/queue-3.19/series b/queue-3.19/series
index b9951490fe8378fdbd6c90b0ed6772d1fd21f7a2..cc07c6fa0b388e38f495eff0a5d3aba62d91ad65 100644 (file)
--- a/queue-3.19/series
+++ b/queue-3.19/series
@@ -16,3 +16,11 @@ asoc-adav80x-fix-wrong-value-references-for-boolean-kctl.patch
 asoc-wm8955-fix-wrong-value-references-for-boolean-kctl.patch
 asoc-wm9712-fix-wrong-value-references-for-boolean-kctl.patch
 asoc-wm9713-fix-wrong-value-references-for-boolean-kctl.patch
+virtio_balloon-set-driver_ok-before-using-device.patch
+virtio-balloon-do-not-call-blocking-ops-when-task_running.patch
+clockevents-sun5i-fix-setup_irq-init-sequence.patch
+regmap-regcache-rbtree-fix-present-bitmap-resize.patch
+regmap-introduce-regmap_name-to-fix-syscon-regmap-trace-events.patch
+clocksource-efm32-fix-a-null-pointer-dereference.patch
+tcm_fc-missing-curly-braces-in-ft_invl_hw_context.patch
+tcm_qla2xxx-fix-incorrect-use-of-__transport_register_session.patch

diff --git a/queue-3.19/tcm_fc-missing-curly-braces-in-ft_invl_hw_context.patch b/queue-3.19/tcm_fc-missing-curly-braces-in-ft_invl_hw_context.patch
new file mode 100644 (file)
index 0000000..b874048
--- /dev/null
+++ b/queue-3.19/tcm_fc-missing-curly-braces-in-ft_invl_hw_context.patch
@@ -0,0 +1,47 @@
+From d556546e7ecd9fca199df4698943024d40044f8e Mon Sep 17 00:00:00 2001
+From: Dan Carpenter <dan.carpenter@oracle.com>
+Date: Wed, 25 Feb 2015 16:21:03 +0300
+Subject: tcm_fc: missing curly braces in ft_invl_hw_context()
+
+From: Dan Carpenter <dan.carpenter@oracle.com>
+
+commit d556546e7ecd9fca199df4698943024d40044f8e upstream.
+
+This patch adds a missing set of conditional check braces in
+ft_invl_hw_context() originally introduced by commit dcd998ccd
+when handling DDP failures in ft_recv_write_data() code.
+
+ commit dcd998ccdbf74a7d8fe0f0a44e85da1ed5975946
+ Author: Kiran Patil <kiran.patil@intel.com>
+ Date:   Wed Aug 3 09:20:01 2011 +0000
+
+    tcm_fc: Handle DDP/SW fc_frame_payload_get failures in ft_recv_write_data
+
+Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
+Cc: Kiran Patil <kiran.patil@intel.com>
+Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+---
+ drivers/target/tcm_fc/tfc_io.c |    3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+--- a/drivers/target/tcm_fc/tfc_io.c
++++ b/drivers/target/tcm_fc/tfc_io.c
+@@ -359,7 +359,7 @@ void ft_invl_hw_context(struct ft_cmd *c
+               ep = fc_seq_exch(seq);
+               if (ep) {
+                       lport = ep->lp;
+-                      if (lport && (ep->xid <= lport->lro_xid))
++                      if (lport && (ep->xid <= lport->lro_xid)) {
+                               /*
+                                * "ddp_done" trigger invalidation of HW
+                                * specific DDP context
+@@ -374,6 +374,7 @@ void ft_invl_hw_context(struct ft_cmd *c
+                                * identified using ep->xid)
+                                */
+                               cmd->was_ddp_setup = 0;
++                      }
+               }
+       }
+ }

diff --git a/queue-3.19/tcm_qla2xxx-fix-incorrect-use-of-__transport_register_session.patch b/queue-3.19/tcm_qla2xxx-fix-incorrect-use-of-__transport_register_session.patch
new file mode 100644 (file)
index 0000000..095c480
--- /dev/null
+++ b/queue-3.19/tcm_qla2xxx-fix-incorrect-use-of-__transport_register_session.patch
@@ -0,0 +1,39 @@
+From 75c3d0bf9caebb502e96683b2bc37f9692437e68 Mon Sep 17 00:00:00 2001
+From: Bart Van Assche <bart.vanassche@sandisk.com>
+Date: Thu, 19 Mar 2015 22:25:16 -0700
+Subject: tcm_qla2xxx: Fix incorrect use of __transport_register_session
+
+From: Bart Van Assche <bart.vanassche@sandisk.com>
+
+commit 75c3d0bf9caebb502e96683b2bc37f9692437e68 upstream.
+
+This patch fixes the incorrect use of __transport_register_session()
+in tcm_qla2xxx_check_initiator_node_acl() code, that does not perform
+explicit se_tpg->session_lock when accessing se_tpg->tpg_sess_list
+to add new se_sess nodes.
+
+Given that tcm_qla2xxx_check_initiator_node_acl() is not called with
+qla_hw->hardware_lock held for all accesses of ->tpg_sess_list, the
+code should be using transport_register_session() instead.
+
+Signed-off-by: Bart Van Assche <bart.vanassche@sandisk.com>
+Cc: Giridhar Malavali <giridhar.malavali@qlogic.com>
+Cc: Quinn Tran <quinn.tran@qlogic.com>
+Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+---
+ drivers/scsi/qla2xxx/tcm_qla2xxx.c |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c
++++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
+@@ -1598,7 +1598,7 @@ static int tcm_qla2xxx_check_initiator_n
+       /*
+        * Finally register the new FC Nexus with TCM
+        */
+-      __transport_register_session(se_nacl->se_tpg, se_nacl, se_sess, sess);
++      transport_register_session(se_nacl->se_tpg, se_nacl, se_sess, sess);
+ 
+       return 0;
+ }

diff --git a/queue-3.19/virtio-balloon-do-not-call-blocking-ops-when-task_running.patch b/queue-3.19/virtio-balloon-do-not-call-blocking-ops-when-task_running.patch
new file mode 100644 (file)
index 0000000..eb4fdf3
--- /dev/null
+++ b/queue-3.19/virtio-balloon-do-not-call-blocking-ops-when-task_running.patch
@@ -0,0 +1,80 @@
+From 3d2a3774c1b046f548ebea0391a602fd5685a307 Mon Sep 17 00:00:00 2001
+From: "Michael S. Tsirkin" <mst@redhat.com>
+Date: Tue, 10 Mar 2015 11:55:08 +1030
+Subject: virtio-balloon: do not call blocking ops when !TASK_RUNNING
+
+From: "Michael S. Tsirkin" <mst@redhat.com>
+
+commit 3d2a3774c1b046f548ebea0391a602fd5685a307 upstream.
+
+virtio balloon has this code:
+        wait_event_interruptible(vb->config_change,
+                                 (diff = towards_target(vb)) != 0
+                                 || vb->need_stats_update
+                                 || kthread_should_stop()
+                                 || freezing(current));
+
+Which is a problem because towards_target() call might block after
+wait_event_interruptible sets task state to TAST_INTERRUPTIBLE, causing
+the task_struct::state collision typical of nesting of sleeping
+primitives
+
+See also http://lwn.net/Articles/628628/ or Thomas's
+bug report
+http://article.gmane.org/gmane.linux.kernel.virtualization/24846
+for a fuller explanation.
+
+To fix, rewrite using wait_woken.
+
+Reported-by: Thomas Huth <thuth@linux.vnet.ibm.com>
+Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
+Tested-by: Thomas Huth <thuth@linux.vnet.ibm.com>
+Reviewed-by: Cornelia Huck <cornelia.huck@de.ibm.com>
+Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+---
+ drivers/virtio/virtio_balloon.c |   19 ++++++++++++++-----
+ 1 file changed, 14 insertions(+), 5 deletions(-)
+
+--- a/drivers/virtio/virtio_balloon.c
++++ b/drivers/virtio/virtio_balloon.c
+@@ -29,6 +29,7 @@
+ #include <linux/module.h>
+ #include <linux/balloon_compaction.h>
+ #include <linux/oom.h>
++#include <linux/wait.h>
+ 
+ /*
+  * Balloon device works in 4K page units.  So each page is pointed to by
+@@ -335,17 +336,25 @@ static int virtballoon_oom_notify(struct
+ static int balloon(void *_vballoon)
+ {
+       struct virtio_balloon *vb = _vballoon;
++      DEFINE_WAIT_FUNC(wait, woken_wake_function);
+ 
+       set_freezable();
+       while (!kthread_should_stop()) {
+               s64 diff;
+ 
+               try_to_freeze();
+-              wait_event_interruptible(vb->config_change,
+-                                       (diff = towards_target(vb)) != 0
+-                                       || vb->need_stats_update
+-                                       || kthread_should_stop()
+-                                       || freezing(current));
++
++              add_wait_queue(&vb->config_change, &wait);
++              for (;;) {
++                      if ((diff = towards_target(vb)) != 0 ||
++                          vb->need_stats_update ||
++                          kthread_should_stop() ||
++                          freezing(current))
++                              break;
++                      wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
++              }
++              remove_wait_queue(&vb->config_change, &wait);
++
+               if (vb->need_stats_update)
+                       stats_handle_request(vb);
+               if (diff > 0)

diff --git a/queue-3.19/virtio_balloon-set-driver_ok-before-using-device.patch b/queue-3.19/virtio_balloon-set-driver_ok-before-using-device.patch
new file mode 100644 (file)
index 0000000..3610151
--- /dev/null
+++ b/queue-3.19/virtio_balloon-set-driver_ok-before-using-device.patch
@@ -0,0 +1,39 @@
+From 88660f7fb94cda1f8f63ee92bfcd0db39a6361e2 Mon Sep 17 00:00:00 2001
+From: "Michael S. Tsirkin" <mst@redhat.com>
+Date: Thu, 5 Mar 2015 13:24:41 +1030
+Subject: virtio_balloon: set DRIVER_OK before using device
+
+From: "Michael S. Tsirkin" <mst@redhat.com>
+
+commit 88660f7fb94cda1f8f63ee92bfcd0db39a6361e2 upstream.
+
+virtio spec requires that all drivers set DRIVER_OK
+before using devices. While balloon isn't yet
+included in the virtio 1 spec, previous spec versions
+also required this.
+
+virtio balloon might violate this rule: probe calls
+kthread_run before setting DRIVER_OK, which might run
+immediately and cause balloon to inflate/deflate.
+
+To fix, call virtio_device_ready before running the kthread.
+
+Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+---
+ drivers/virtio/virtio_balloon.c |    2 ++
+ 1 file changed, 2 insertions(+)
+
+--- a/drivers/virtio/virtio_balloon.c
++++ b/drivers/virtio/virtio_balloon.c
+@@ -494,6 +494,8 @@ static int virtballoon_probe(struct virt
+       if (err < 0)
+               goto out_oom_notify;
+ 
++      virtio_device_ready(vdev);
++
+       vb->thread = kthread_run(balloon, vb, "vballoon");
+       if (IS_ERR(vb->thread)) {
+               err = PTR_ERR(vb->thread);