· 10 years ago · Apr 20, 2016, 10:18 AM
1diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
2index c7b8722..f33c44d 100644
3--- a/drivers/mmc/host/Kconfig
4+++ b/drivers/mmc/host/Kconfig
5@@ -79,17 +79,16 @@ config MMC_SDHCI_PLTFM_KONA
6 If unsure, say N.
7
8 config MMC_KONA_SDIO_WIFI
9- tristate "SDIO Wifi support on KONA platform bus"
10- depends on MMC_SDHCI_PLTFM_KONA
11- default n
12- select CONFIG_BCM_SDIOWL
13- help
14- This selects the Broadcom SDIO Wifi control driver for the KONA platform.
15-
16- If you have a controller with this interface, say Y or M here.
17+ tristate "SDIO Wifi support on KONA platform bus"
18+ depends on MMC_SDHCI_PLTFM_KONA
19+ default n
20+ select CONFIG_BCM_SDIOWL
21+ help
22+ This selects the Broadcom SDIO Wifi control driver for the KONA platform.
23
24- If unsure, say N.
25+ If you have a controller with this interface, say Y or M here.
26
27+ If unsure, say N.
28 config MMC_RICOH_MMC
29 bool "Ricoh MMC Controller Disabler"
30 depends on MMC_SDHCI_PCI
31diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
32index 6a4705a..71de7c6 100644
33--- a/drivers/mmc/host/Makefile
34+++ b/drivers/mmc/host/Makefile
35@@ -21,7 +21,6 @@ obj-$(CONFIG_MMC_OMAP) += omap.o
36 obj-$(CONFIG_MMC_OMAP_HS) += omap_hsmmc.o
37 obj-$(CONFIG_MMC_ATMELMCI) += atmel-mci.o
38 obj-$(CONFIG_MMC_TIFM_SD) += tifm_sd.o
39-obj-$(CONFIG_MMC_MSM) += msm_sdcc.o
40 obj-$(CONFIG_MMC_MVSDIO) += mvsdio.o
41 obj-$(CONFIG_MMC_DAVINCI) += davinci_mmc.o
42 obj-$(CONFIG_MMC_GOLDFISH) += android-goldfish.o
43@@ -64,6 +63,7 @@ obj-$(CONFIG_MMC_SDHCI_TEGRA) += sdhci-tegra.o
44 obj-$(CONFIG_MMC_SDHCI_OF_ESDHC) += sdhci-of-esdhc.o
45 obj-$(CONFIG_MMC_SDHCI_OF_HLWD) += sdhci-of-hlwd.o
46 obj-$(CONFIG_MMC_SDHCI_BCM2835) += sdhci-bcm2835.o
47+obj-$(CONFIG_MMC_SDHCI_MSM) += sdhci-msm.o
48
49 ifeq ($(CONFIG_CB710_DEBUG),y)
50 CFLAGS-cb710-mmc += -DDEBUG
51diff --git a/drivers/mmc/host/sdhci-pltfm-kona.c b/drivers/mmc/host/sdhci-pltfm-kona.c
52index 85ddb28..24ff147 100644
53--- a/drivers/mmc/host/sdhci-pltfm-kona.c
54+++ b/drivers/mmc/host/sdhci-pltfm-kona.c
55@@ -143,7 +143,6 @@ static void sdhci_pltfm_init_74_clocks(struct sdhci_host *host,
56 static int sdhci_pltfm_rpm_enabled(struct sdio_dev *dev);
57 static int sdhci_rpm_enabled(struct sdhci_host *host);
58 static int sdhci_clk_enable(struct sdhci_host *host, int enable);
59-static void sdhci_print_critical(struct sdhci_host *host);
60
61 /*
62 * Get the base clock. Use central clock source for now. Not sure if different
63@@ -175,7 +174,6 @@ static struct sdhci_ops sdhci_pltfm_ops = {
64 .rpm_enabled = sdhci_rpm_enabled,
65 .set_signalling = sdhci_pltfm_set_signalling,
66 .platform_send_init_74_clocks = sdhci_pltfm_init_74_clocks,
67- .sdhci_debug = sdhci_print_critical,
68 };
69
70 static int bcm_kona_sd_reset(struct sdio_dev *dev)
71@@ -1667,20 +1665,3 @@ static void sdhci_pltfm_init_74_clocks(struct sdhci_host *host, u8 power_mode)
72 mdelay(1);
73 }
74
75-static void sdhci_print_critical(struct sdhci_host *host)
76-{
77- struct sdio_dev *dev = sdhci_priv(host);
78- int ret = 0;
79-
80- if (dev->vdd_sdxc_regulator) {
81- ret = irqsafe_is_regulator_enable(dev->vdd_sdxc_regulator);
82- printk(KERN_ALERT "regulator enable:%d\n", ret);
83- }
84- if (dev->vddo_sd_regulator) {
85- ret = irqsafe_is_regulator_enable(dev->vddo_sd_regulator);
86- printk(KERN_ALERT "sd regulator enable:%d\n", ret);
87- }
88- printk(KERN_ALERT "runtime_suspended:%d\n", host->runtime_suspended);
89- ret = atomic_read(&dev->dev->power.usage_count);
90- printk(KERN_ALERT "pm runtime usage count:%d\n", ret);
91-}
92diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
93index 8d005cc..62dfb2b 100644
94--- a/drivers/mmc/host/sdhci.c
95+++ b/drivers/mmc/host/sdhci.c
96@@ -23,25 +23,20 @@
97 #include <linux/regulator/consumer.h>
98 #include <linux/pm_runtime.h>
99
100-#ifdef CONFIG_SDHCI_THROUGHPUT
101-#include <linux/debugfs.h>
102-#include <asm/div64.h>
103-#endif
104-
105 #include <linux/leds.h>
106
107 #include <linux/mmc/mmc.h>
108 #include <linux/mmc/host.h>
109 #include <linux/mmc/card.h>
110 #include <linux/mmc/slot-gpio.h>
111-#include <linux/mmc/sd.h>
112-#include <linux/debugfs.h>
113+#include <linux/mmc/sdio.h>
114
115-#define CONFIG_MMC_ARASAN_HOST_FIX
116+#include <trace/events/mmc.h>
117
118 #include "sdhci.h"
119
120 #define DRIVER_NAME "sdhci"
121+#define SDHCI_SUSPEND_TIMEOUT 300 /* 300 ms */
122
123 #define DBG(f, x...) \
124 pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x)
125@@ -51,31 +46,13 @@
126 #define SDHCI_USE_LEDS_CLASS
127 #endif
128
129-#define MAX_TUNING_LOOP 40
130-#define SDHCI_MAX_BUSY_WAIT 15
131+#define MAX_TUNING_LOOP 40
132+
133+#define SDHCI_DBG_DUMP_RS_INTERVAL (10 * HZ)
134+#define SDHCI_DBG_DUMP_RS_BURST 2
135
136 static unsigned int debug_quirks = 0;
137 static unsigned int debug_quirks2;
138-#ifdef CONFIG_SDHCI_THROUGHPUT
139-
140-static struct dentry *sdhci_throughput_dentry;
141-
142-typedef struct sdhci_throughput {
143- u16 read;
144- u16 dir;
145- u32 blk_size;
146- u32 nm_of_blks;
147- u32 bytes_tx[2];
148- struct timeval t1;
149- struct timeval t2;
150- struct timeval tot_time[2];
151- struct dentry *dentry[3];
152-
153-} sdhci_throughput_t;
154-
155-struct sdhci_throughput *mmc_throughput;
156-
157-#endif
158
159 static void sdhci_finish_data(struct sdhci_host *);
160
161@@ -84,10 +61,21 @@ static void sdhci_finish_command(struct sdhci_host *);
162 static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode);
163 static void sdhci_tuning_timer(unsigned long data);
164 static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable);
165+static bool sdhci_check_state(struct sdhci_host *);
166+static void sdhci_show_adma_error(struct sdhci_host *host);
167
168 #ifdef CONFIG_PM_RUNTIME
169 static int sdhci_runtime_pm_get(struct sdhci_host *host);
170 static int sdhci_runtime_pm_put(struct sdhci_host *host);
171+static void sdhci_dump_rpm_info(struct sdhci_host *host)
172+{
173+ struct mmc_host *mmc = host->mmc;
174+
175+ pr_info("%s: rpmstatus[pltfm](runtime-suspend:usage_count:disable_depth)(%d:%d:%d)\n",
176+ mmc_hostname(mmc), mmc->parent->power.runtime_status,
177+ atomic_read(&mmc->parent->power.usage_count),
178+ mmc->parent->power.disable_depth);
179+}
180 #else
181 static inline int sdhci_runtime_pm_get(struct sdhci_host *host)
182 {
183@@ -97,8 +85,27 @@ static inline int sdhci_runtime_pm_put(struct sdhci_host *host)
184 {
185 return 0;
186 }
187+static void sdhci_dump_rpm_info(struct sdhci_host *host)
188+{
189+}
190 #endif
191
192+static inline int sdhci_get_async_int_status(struct sdhci_host *host)
193+{
194+ return (sdhci_readw(host, SDHCI_HOST_CONTROL2) &
195+ SDHCI_CTRL_ASYNC_INT_ENABLE) >> 14;
196+}
197+
198+static void sdhci_dump_state(struct sdhci_host *host)
199+{
200+ struct mmc_host *mmc = host->mmc;
201+
202+ pr_info("%s: clk: %d clk-gated: %d claimer: %s pwr: %d\n",
203+ mmc_hostname(mmc), host->clock, mmc->clk_gated,
204+ mmc->claimer->comm, host->pwr);
205+ sdhci_dump_rpm_info(host);
206+}
207+
208 static void sdhci_dumpregs(struct sdhci_host *host)
209 {
210 pr_info(DRIVER_NAME ": =========== REGISTER DUMP (%s)===========\n",
211@@ -129,7 +136,7 @@ static void sdhci_dumpregs(struct sdhci_host *host)
212 sdhci_readl(host, SDHCI_INT_ENABLE),
213 sdhci_readl(host, SDHCI_SIGNAL_ENABLE));
214 pr_info(DRIVER_NAME ": AC12 err: 0x%08x | Slot int: 0x%08x\n",
215- sdhci_readw(host, SDHCI_ACMD12_ERR),
216+ host->auto_cmd_err_sts,
217 sdhci_readw(host, SDHCI_SLOT_INT_STATUS));
218 pr_info(DRIVER_NAME ": Caps: 0x%08x | Caps_1: 0x%08x\n",
219 sdhci_readl(host, SDHCI_CAPABILITIES),
220@@ -137,17 +144,60 @@ static void sdhci_dumpregs(struct sdhci_host *host)
221 pr_info(DRIVER_NAME ": Cmd: 0x%08x | Max curr: 0x%08x\n",
222 sdhci_readw(host, SDHCI_COMMAND),
223 sdhci_readl(host, SDHCI_MAX_CURRENT));
224+ pr_info(DRIVER_NAME ": Resp 1: 0x%08x | Resp 0: 0x%08x\n",
225+ sdhci_readl(host, SDHCI_RESPONSE + 0x4),
226+ sdhci_readl(host, SDHCI_RESPONSE));
227+ pr_info(DRIVER_NAME ": Resp 3: 0x%08x | Resp 2: 0x%08x\n",
228+ sdhci_readl(host, SDHCI_RESPONSE + 0xC),
229+ sdhci_readl(host, SDHCI_RESPONSE + 0x8));
230 pr_info(DRIVER_NAME ": Host ctl2: 0x%08x\n",
231 sdhci_readw(host, SDHCI_HOST_CONTROL2));
232
233- if (host->flags & SDHCI_USE_ADMA)
234+ if (host->flags & SDHCI_USE_ADMA_64BIT) {
235+ pr_info(DRIVER_NAME ": ADMA Err: 0x%08x\n",
236+ readl(host->ioaddr + SDHCI_ADMA_ERROR));
237+ pr_info(DRIVER_NAME ": ADMA Addr(0:31): 0x%08x | ADMA Addr(32:63): 0x%08x\n",
238+ readl(host->ioaddr + SDHCI_ADMA_ADDRESS_LOW),
239+ readl(host->ioaddr + SDHCI_ADMA_ADDRESS_HIGH));
240+ } else if (host->flags & SDHCI_USE_ADMA) {
241 pr_info(DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n",
242 readl(host->ioaddr + SDHCI_ADMA_ERROR),
243- readl(host->ioaddr + SDHCI_ADMA_ADDRESS));
244+ readl(host->ioaddr + SDHCI_ADMA_ADDRESS_LOW));
245+ }
246
247+ if (host->ops->dump_vendor_regs)
248+ host->ops->dump_vendor_regs(host);
249+ sdhci_dump_state(host);
250 pr_info(DRIVER_NAME ": ===========================================\n");
251 }
252
253+#define MAX_PM_QOS_TIMEOUT_VALUE 100000 /* 100 ms */
254+static ssize_t
255+show_sdhci_pm_qos_tout(struct device *dev, struct device_attribute *attr,
256+ char *buf)
257+{
258+ struct sdhci_host *host = dev_get_drvdata(dev);
259+
260+ return snprintf(buf, PAGE_SIZE, "%d us\n", host->pm_qos_timeout_us);
261+}
262+
263+static ssize_t
264+store_sdhci_pm_qos_tout(struct device *dev, struct device_attribute *attr,
265+ const char *buf, size_t count)
266+{
267+ struct sdhci_host *host = dev_get_drvdata(dev);
268+ uint32_t value;
269+ unsigned long flags;
270+
271+ if (!kstrtou32(buf, 0, &value)) {
272+ spin_lock_irqsave(&host->lock, flags);
273+ if (value <= MAX_PM_QOS_TIMEOUT_VALUE)
274+ host->pm_qos_timeout_us = value;
275+ spin_unlock_irqrestore(&host->lock, flags);
276+ }
277+ return count;
278+}
279+
280 /*****************************************************************************\
281 * *
282 * Low level functions *
283@@ -177,10 +227,15 @@ static void sdhci_mask_irqs(struct sdhci_host *host, u32 irqs)
284
285 static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
286 {
287- u32 irqs = SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT;
288+ u32 present, irqs;
289+
290 if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
291 return;
292
293+ present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
294+ SDHCI_CARD_PRESENT;
295+ irqs = present ? SDHCI_INT_CARD_REMOVE : SDHCI_INT_CARD_INSERT;
296+
297 if (enable)
298 sdhci_unmask_irqs(host, irqs);
299 else
300@@ -220,7 +275,11 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
301 host->clock = 0;
302
303 /* Wait max 100 ms */
304- timeout = 1000;
305+ timeout = 100000;
306+
307+ if (host->ops->check_power_status && host->pwr &&
308+ (mask & SDHCI_RESET_ALL))
309+ host->ops->check_power_status(host, REQ_BUS_OFF);
310
311 /* hw clears the bit when it's done */
312 while (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) {
313@@ -231,12 +290,16 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
314 return;
315 }
316 timeout--;
317- mdelay(1);
318+ udelay(1);
319 }
320
321 if (host->ops->platform_reset_exit)
322 host->ops->platform_reset_exit(host, mask);
323
324+ /* clear pending normal/error interrupt status */
325+ sdhci_writel(host, sdhci_readl(host, SDHCI_INT_STATUS),
326+ SDHCI_INT_STATUS);
327+
328 if (host->quirks & SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
329 sdhci_clear_set_irqs(host, SDHCI_INT_ALL_MASK, ier);
330
331@@ -314,7 +377,7 @@ static void sdhci_led_control(struct led_classdev *led,
332
333 spin_lock_irqsave(&host->lock, flags);
334
335- if (host->runtime_suspended)
336+ if (host->runtime_suspended || sdhci_check_state(host))
337 goto out;
338
339 if (brightness == LED_OFF)
340@@ -475,25 +538,70 @@ static void sdhci_kunmap_atomic(void *buffer, unsigned long *flags)
341 local_irq_restore(*flags);
342 }
343
344-static void sdhci_set_adma_desc(u8 *desc, u32 addr, int len, unsigned cmd)
345+static void sdhci_set_adma_desc(struct sdhci_host *host, u8 *desc,
346+ dma_addr_t addr, int len, unsigned cmd)
347 {
348- __le32 *dataddr = (__le32 __force *)(desc + 4);
349 __le16 *cmdlen = (__le16 __force *)desc;
350
351- /* SDHCI specification says ADMA descriptors should be 4 byte
352- * aligned, so using 16 or 32bit operations should be safe. */
353+ /*
354+ * SDHCI specification says ADMA descriptors should be 4 byte
355+ * or 8 byte aligned, so using 16 or 32 or 64bit operations
356+ * should be safe.
357+ */
358
359 cmdlen[0] = cpu_to_le16(cmd);
360 cmdlen[1] = cpu_to_le16(len);
361
362- dataddr[0] = cpu_to_le32(addr);
363+ if (host->flags & SDHCI_USE_ADMA_64BIT) {
364+ __le64 *dataddr = (__le64 __force *)(desc + 4);
365+ dataddr[0] = cpu_to_le64(addr);
366+ } else {
367+ __le32 *dataddr = (__le32 __force *)(desc + 4);
368+ dataddr[0] = cpu_to_le32(addr);
369+ }
370+}
371+
372+static int sdhci_pre_dma_transfer(struct sdhci_host *host,
373+ struct mmc_data *data,
374+ struct sdhci_next *next)
375+{
376+ int sg_count;
377+
378+ if (!next && data->host_cookie &&
379+ data->host_cookie != host->next_data.cookie) {
380+ printk(KERN_WARNING "[%s] invalid cookie: data->host_cookie %d"
381+ " host->next_data.cookie %d\n",
382+ __func__, data->host_cookie, host->next_data.cookie);
383+ data->host_cookie = 0;
384+ }
385+
386+ /* Check if next job is already prepared */
387+ if (next ||
388+ (!next && data->host_cookie != host->next_data.cookie)) {
389+ sg_count = dma_map_sg(mmc_dev(host->mmc), data->sg,
390+ data->sg_len,
391+ (data->flags & MMC_DATA_WRITE) ?
392+ DMA_TO_DEVICE : DMA_FROM_DEVICE);
393+ } else {
394+ sg_count = host->next_data.sg_count;
395+ host->next_data.sg_count = 0;
396+ }
397+
398+ if (sg_count == 0)
399+ return -EINVAL;
400+
401+ if (next) {
402+ next->sg_count = sg_count;
403+ data->host_cookie = ++next->cookie < 0 ? 1 : next->cookie;
404+ } else
405+ host->sg_count = sg_count;
406+
407+ return sg_count;
408 }
409
410 static int sdhci_adma_table_pre(struct sdhci_host *host,
411 struct mmc_data *data)
412 {
413- int direction;
414-
415 u8 *desc;
416 u8 *align;
417 dma_addr_t addr;
418@@ -510,26 +618,9 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
419 * We currently guess that it is LE.
420 */
421
422- if (data->flags & MMC_DATA_READ)
423- direction = DMA_FROM_DEVICE;
424- else
425- direction = DMA_TO_DEVICE;
426-
427- /*
428- * The ADMA descriptor table is mapped further down as we
429- * need to fill it with data first.
430- */
431-
432- host->align_addr = dma_map_single(mmc_dev(host->mmc),
433- host->align_buffer, 128 * 4, direction);
434- if (dma_mapping_error(mmc_dev(host->mmc), host->align_addr))
435+ host->sg_count = sdhci_pre_dma_transfer(host, data, NULL);
436+ if (host->sg_count < 0)
437 goto fail;
438- BUG_ON(host->align_addr & 0x3);
439-
440- host->sg_count = dma_map_sg(mmc_dev(host->mmc),
441- data->sg, data->sg_len, direction);
442- if (host->sg_count == 0)
443- goto unmap_align;
444
445 desc = host->adma_desc;
446 align = host->align_buffer;
447@@ -540,47 +631,50 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
448 addr = sg_dma_address(sg);
449 len = sg_dma_len(sg);
450
451- /*
452- * The SDHCI specification states that ADMA
453- * addresses must be 32-bit aligned. If they
454- * aren't, then we use a bounce buffer for
455- * the (up to three) bytes that screw up the
456- * alignment.
457- */
458- offset = (4 - (addr & 0x3)) & 0x3;
459- if (offset) {
460- if (data->flags & MMC_DATA_WRITE) {
461- buffer = sdhci_kmap_atomic(sg, &flags);
462- WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
463- memcpy(align, buffer, offset);
464- sdhci_kunmap_atomic(buffer, &flags);
465- }
466-
467- /* tran, valid */
468- sdhci_set_adma_desc(desc, align_addr, offset, 0x21);
469-
470- BUG_ON(offset > 65536);
471-
472- align += 4;
473- align_addr += 4;
474-
475- desc += 8;
476-
477- addr += offset;
478- len -= offset;
479+ /*
480+ * The SDHCI specification states that ADMA
481+ * addresses must be 32-bit aligned. If they
482+ * aren't, then we use a bounce buffer for
483+ * the (up to three) bytes that screw up the
484+ * alignment.
485+ */
486+ offset = (4 - (addr & 0x3)) & 0x3;
487+ if (offset) {
488+ if (data->flags & MMC_DATA_WRITE) {
489+ buffer = sdhci_kmap_atomic(sg, &flags);
490+ WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
491+ memcpy(align, buffer, offset);
492+ sdhci_kunmap_atomic(buffer, &flags);
493+ }
494+
495+ /* tran, valid */
496+ sdhci_set_adma_desc(host, desc, align_addr, offset, 0x21);
497+
498+ BUG_ON(offset > 65536);
499+
500+ align += 4;
501+ align_addr += 4;
502+
503+ desc += 8;
504+
505+ addr += offset;
506+ len -= offset;
507 }
508
509 BUG_ON(len > 65536);
510
511- /* tran, valid */
512- sdhci_set_adma_desc(desc, addr, len, 0x21);
513- desc += 8;
514+ if (len) {
515+ /* tran, valid */
516+ sdhci_set_adma_desc(host, desc, addr, len, 0x21);
517+ desc += host->adma_desc_line_sz;
518+ }
519
520 /*
521 * If this triggers then we have a calculation bug
522 * somewhere. :/
523 */
524- WARN_ON((desc - host->adma_desc) > (128 * 2 + 1) * 4);
525+ WARN_ON((desc - host->adma_desc) > host->adma_desc_sz);
526+
527 }
528
529 if (host->quirks & SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC) {
530@@ -588,7 +682,7 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
531 * Mark the last descriptor as the terminating descriptor
532 */
533 if (desc != host->adma_desc) {
534- desc -= 8;
535+ desc -= host->adma_desc_line_sz;
536 desc[0] |= 0x2; /* end */
537 }
538 } else {
539@@ -597,31 +691,11 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
540 */
541
542 /* nop, end, valid */
543- sdhci_set_adma_desc(desc, 0, 0, 0x3);
544+ sdhci_set_adma_desc(host, desc, 0, 0, 0x3);
545 }
546
547- /*
548- * Resync align buffer as we might have changed it.
549- */
550- if (data->flags & MMC_DATA_WRITE) {
551- dma_sync_single_for_device(mmc_dev(host->mmc),
552- host->align_addr, 128 * 4, direction);
553- }
554-
555- host->adma_addr = dma_map_single(mmc_dev(host->mmc),
556- host->adma_desc, (128 * 2 + 1) * 4, DMA_TO_DEVICE);
557- if (dma_mapping_error(mmc_dev(host->mmc), host->adma_addr))
558- goto unmap_entries;
559- BUG_ON(host->adma_addr & 0x3);
560-
561 return 0;
562
563-unmap_entries:
564- dma_unmap_sg(mmc_dev(host->mmc), data->sg,
565- data->sg_len, direction);
566-unmap_align:
567- dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
568- 128 * 4, direction);
569 fail:
570 return -EINVAL;
571 }
572@@ -629,47 +703,61 @@ fail:
573 static void sdhci_adma_table_post(struct sdhci_host *host,
574 struct mmc_data *data)
575 {
576- int direction;
577-
578+ int direction = (data->flags & MMC_DATA_WRITE)
579+ ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
580 struct scatterlist *sg;
581 int i, size;
582 u8 *align;
583 char *buffer;
584 unsigned long flags;
585+ bool has_unaligned = false;
586+ u32 command = SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND));
587
588- if (data->flags & MMC_DATA_READ)
589- direction = DMA_FROM_DEVICE;
590- else
591- direction = DMA_TO_DEVICE;
592+ trace_mmc_adma_table_post(command, data->sg_len);
593
594- dma_unmap_single(mmc_dev(host->mmc), host->adma_addr,
595- (128 * 2 + 1) * 4, DMA_TO_DEVICE);
596+ if (!(host->quirks2 & SDHCI_QUIRK2_ADMA_SKIP_DATA_ALIGNMENT)
597+ && (data->flags & MMC_DATA_READ)) {
598
599- dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
600- 128 * 4, direction);
601+ /* Do a quick scan of the SG list for any unaligned mappings */
602+ for_each_sg(data->sg, sg, host->sg_count, i) {
603+ if (sg_dma_address(sg) & (host->align_bytes - 1)) {
604+ has_unaligned = true;
605+ break;
606+ }
607+ }
608+ }
609
610- if (data->flags & MMC_DATA_READ) {
611+ if (!(host->quirks2 & SDHCI_QUIRK2_ADMA_SKIP_DATA_ALIGNMENT)
612+ && has_unaligned) {
613 dma_sync_sg_for_cpu(mmc_dev(host->mmc), data->sg,
614 data->sg_len, direction);
615
616 align = host->align_buffer;
617
618 for_each_sg(data->sg, sg, host->sg_count, i) {
619- if (sg_dma_address(sg) & 0x3) {
620- size = 4 - (sg_dma_address(sg) & 0x3);
621+ if (sg_dma_address(sg) & (host->align_bytes - 1)) {
622+ size = host->align_bytes - (sg_dma_address(sg)
623+ & (host->align_bytes - 1));
624
625 buffer = sdhci_kmap_atomic(sg, &flags);
626- WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
627+ /*
628+ * This check is intended here to verify if the
629+ * page offset plus alignment bytes is indeed
630+ * within the same page.
631+ */
632+ WARN_ON(((long)buffer & (PAGE_SIZE - 1)) >
633+ (PAGE_SIZE - (host->align_bytes - 1)));
634 memcpy(buffer, align, size);
635 sdhci_kunmap_atomic(buffer, &flags);
636
637- align += 4;
638+ align += host->align_bytes;
639 }
640 }
641 }
642
643- dma_unmap_sg(mmc_dev(host->mmc), data->sg,
644- data->sg_len, direction);
645+ if (!data->host_cookie)
646+ dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
647+ direction);
648 }
649
650 static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
651@@ -677,6 +765,7 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
652 u8 count;
653 struct mmc_data *data = cmd->data;
654 unsigned target_timeout, current_timeout;
655+ u32 curr_clk = 0; /* In KHz */
656
657 /*
658 * If the host controller provides us with an incorrect timeout
659@@ -684,13 +773,8 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
660 * longer to time out, but that's much better than having a too-short
661 * timeout value.
662 */
663- if (host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL) {
664-#ifdef CONFIG_MACH_BCM_FPGA
665- return 0x8;
666-#else
667+ if (host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL)
668 return 0xE;
669-#endif
670- }
671
672 /* Unspecified timeout, assume max */
673 if (!data && !cmd->cmd_timeout_ms)
674@@ -716,7 +800,14 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
675 * (1) / (2) > 2^6
676 */
677 count = 0;
678- current_timeout = (1 << 13) * 1000 / host->timeout_clk;
679+ if (host->quirks2 & SDHCI_QUIRK2_ALWAYS_USE_BASE_CLOCK) {
680+ curr_clk = host->clock / 1000;
681+ if (host->quirks2 & SDHCI_QUIRK2_DIVIDE_TOUT_BY_4)
682+ curr_clk /= 4;
683+ current_timeout = (1 << 13) * 1000 / curr_clk;
684+ } else {
685+ current_timeout = (1 << 13) * 1000 / host->timeout_clk;
686+ }
687 while (current_timeout < target_timeout) {
688 count++;
689 current_timeout <<= 1;
690@@ -724,10 +815,12 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
691 break;
692 }
693
694- if (count >= 0xF) {
695- DBG("%s: Too large timeout 0x%x requested for CMD%d!\n",
696- mmc_hostname(host->mmc), count, cmd->opcode);
697- count = 0xE;
698+ if (!(host->quirks2 & SDHCI_QUIRK2_USE_RESERVED_MAX_TIMEOUT)) {
699+ if (count >= 0xF) {
700+ DBG("%s: Too large timeout 0x%x requested for CMD%d!\n",
701+ mmc_hostname(host->mmc), count, cmd->opcode);
702+ count = 0xE;
703+ }
704 }
705
706 return count;
707@@ -744,6 +837,17 @@ static void sdhci_set_transfer_irqs(struct sdhci_host *host)
708 sdhci_clear_set_irqs(host, dma_irqs, pio_irqs);
709 }
710
711+static void sdhci_set_blk_size_reg(struct sdhci_host *host, unsigned int blksz,
712+ unsigned int sdma_boundary)
713+{
714+ if (host->flags & SDHCI_USE_ADMA)
715+ sdhci_writew(host, SDHCI_MAKE_BLKSZ(0, blksz),
716+ SDHCI_BLOCK_SIZE);
717+ else
718+ sdhci_writew(host, SDHCI_MAKE_BLKSZ(sdma_boundary, blksz),
719+ SDHCI_BLOCK_SIZE);
720+}
721+
722 static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
723 {
724 u8 count;
725@@ -762,7 +866,7 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
726 return;
727
728 /* Sanity checks */
729- BUG_ON(data->blksz * data->blocks > 524288);
730+ BUG_ON(data->blksz * data->blocks > host->mmc->max_req_size);
731 BUG_ON(data->blksz > host->mmc->max_blk_size);
732 BUG_ON(data->blocks > 65535);
733
734@@ -839,6 +943,7 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
735
736 if (host->flags & SDHCI_REQ_USE_DMA) {
737 if (host->flags & SDHCI_USE_ADMA) {
738+ trace_mmc_adma_table_pre(cmd->opcode, data->sg_len);
739 ret = sdhci_adma_table_pre(host, data);
740 if (ret) {
741 /*
742@@ -848,17 +953,23 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
743 WARN_ON(1);
744 host->flags &= ~SDHCI_REQ_USE_DMA;
745 } else {
746- sdhci_writel(host, host->adma_addr,
747- SDHCI_ADMA_ADDRESS);
748+ if (host->flags & SDHCI_USE_ADMA_64BIT) {
749+ sdhci_writel(host,
750+ (u32)host->adma_addr,
751+ SDHCI_ADMA_ADDRESS_LOW);
752+ sdhci_writel(host,
753+ (u32)((u64)host->adma_addr
754+ >> SDHCI_HI_SHIFT),
755+ SDHCI_ADMA_ADDRESS_HIGH);
756+ } else {
757+ sdhci_writel(host, host->adma_addr,
758+ SDHCI_ADMA_ADDRESS_LOW);
759+ }
760 }
761 } else {
762 int sg_cnt;
763
764- sg_cnt = dma_map_sg(mmc_dev(host->mmc),
765- data->sg, data->sg_len,
766- (data->flags & MMC_DATA_READ) ?
767- DMA_FROM_DEVICE :
768- DMA_TO_DEVICE);
769+ sg_cnt = sdhci_pre_dma_transfer(host, data, NULL);
770 if (sg_cnt == 0) {
771 /*
772 * This only happens when someone fed
773@@ -883,10 +994,14 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
774 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
775 ctrl &= ~SDHCI_CTRL_DMA_MASK;
776 if ((host->flags & SDHCI_REQ_USE_DMA) &&
777- (host->flags & SDHCI_USE_ADMA))
778- ctrl |= SDHCI_CTRL_ADMA32;
779- else
780+ (host->flags & SDHCI_USE_ADMA)) {
781+ if (host->flags & SDHCI_USE_ADMA_64BIT)
782+ ctrl |= SDHCI_CTRL_ADMA64;
783+ else
784+ ctrl |= SDHCI_CTRL_ADMA32;
785+ } else {
786 ctrl |= SDHCI_CTRL_SDMA;
787+ }
788 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
789 }
790
791@@ -905,8 +1020,7 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
792 sdhci_set_transfer_irqs(host);
793
794 /* Set the DMA boundary value and block size */
795- sdhci_writew(host, SDHCI_MAKE_BLKSZ(SDHCI_DEFAULT_BOUNDARY_ARG,
796- data->blksz), SDHCI_BLOCK_SIZE);
797+ sdhci_set_blk_size_reg(host, data->blksz, SDHCI_DEFAULT_BOUNDARY_ARG);
798 sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
799 }
800
801@@ -936,20 +1050,16 @@ static void sdhci_set_transfer_mode(struct sdhci_host *host,
802 }
803 }
804
805- if (data->flags & MMC_DATA_READ)
806+ if (data->flags & MMC_DATA_READ) {
807 mode |= SDHCI_TRNS_READ;
808+ if (host->ops->toggle_cdr)
809+ host->ops->toggle_cdr(host, true);
810+ }
811+ if (host->ops->toggle_cdr && (data->flags & MMC_DATA_WRITE))
812+ host->ops->toggle_cdr(host, false);
813 if (host->flags & SDHCI_REQ_USE_DMA)
814 mode |= SDHCI_TRNS_DMA;
815
816-#ifdef CONFIG_SDHCI_THROUGHPUT
817- if (unlikely(host->thrpt_dbgfs_enable)) {
818- (mmc_throughput[host->mmc->index]).read = data->flags;
819- (mmc_throughput[host->mmc->index]).blk_size = data->blksz;
820- (mmc_throughput[host->mmc->index]).nm_of_blks = data->blocks;
821- do_gettimeofday(&((mmc_throughput[host->mmc->index]).t1));
822- }
823-#endif
824-
825 sdhci_writew(host, mode, SDHCI_TRANSFER_MODE);
826 }
827
828@@ -966,9 +1076,11 @@ static void sdhci_finish_data(struct sdhci_host *host)
829 if (host->flags & SDHCI_USE_ADMA)
830 sdhci_adma_table_post(host, data);
831 else {
832- dma_unmap_sg(mmc_dev(host->mmc), data->sg,
833- data->sg_len, (data->flags & MMC_DATA_READ) ?
834- DMA_FROM_DEVICE : DMA_TO_DEVICE);
835+ if (!data->host_cookie)
836+ dma_unmap_sg(mmc_dev(host->mmc), data->sg,
837+ data->sg_len,
838+ (data->flags & MMC_DATA_READ) ?
839+ DMA_FROM_DEVICE : DMA_TO_DEVICE);
840 }
841 }
842
843@@ -1007,6 +1119,8 @@ static void sdhci_finish_data(struct sdhci_host *host)
844 tasklet_schedule(&host->finish_tasklet);
845 }
846
847+#define SDHCI_REQUEST_TIMEOUT 10 /* Default request timeout in seconds */
848+
849 static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
850 {
851 int flags;
852@@ -1015,14 +1129,8 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
853
854 WARN_ON(host->cmd);
855
856-#ifdef CONFIG_MMC_BCM_SD
857- DBG("%s: CMD:[%d] SDHC_PRESENT_STATE=0x%x; Command Arg=0x%x\n",
858- mmc_hostname(host->mmc), cmd->opcode,
859- sdhci_readl(host, SDHCI_PRESENT_STATE), cmd->arg);
860-#endif
861-
862 /* Wait max 10 ms */
863- timeout = 10;
864+ timeout = 10000;
865
866 mask = SDHCI_CMD_INHIBIT;
867 if ((cmd->data != NULL) || (cmd->flags & MMC_RSP_BUSY))
868@@ -1043,10 +1151,14 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
869 return;
870 }
871 timeout--;
872- mdelay(1);
873+ udelay(1);
874 }
875
876- mod_timer(&host->timer, jiffies + 10 * HZ);
877+ mod_timer(&host->timer, jiffies + SDHCI_REQUEST_TIMEOUT * HZ);
878+
879+ if (cmd->cmd_timeout_ms > SDHCI_REQUEST_TIMEOUT * MSEC_PER_SEC)
880+ mod_timer(&host->timer, jiffies +
881+ (msecs_to_jiffies(cmd->cmd_timeout_ms * 2)));
882
883 host->cmd = cmd;
884
885@@ -1080,9 +1192,13 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
886
887 /* CMD19 is special in that the Data Present Select should be set */
888 if (cmd->data || cmd->opcode == MMC_SEND_TUNING_BLOCK ||
889+ cmd->opcode == MMC_SEND_TUNING_BLOCK_HS400 ||
890 cmd->opcode == MMC_SEND_TUNING_BLOCK_HS200)
891 flags |= SDHCI_CMD_DATA;
892
893+ if (cmd->data)
894+ host->data_start_time = ktime_get();
895+ trace_mmc_cmd_rw_start(cmd->opcode, cmd->arg, cmd->flags);
896 sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
897 }
898
899@@ -1108,10 +1224,9 @@ static void sdhci_finish_command(struct sdhci_host *host)
900 }
901 }
902
903- host->cmd->error = 0;
904-
905 /* Finished CMD23, now send actual command. */
906 if (host->cmd == host->mrq->sbc) {
907+ host->cmd->error = 0;
908 host->cmd = NULL;
909 sdhci_send_command(host, host->mrq->cmd);
910 } else {
911@@ -1164,19 +1279,24 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
912 int real_div = div, clk_mul = 1;
913 u16 clk = 0;
914 unsigned long timeout;
915+ unsigned long flags;
916
917+ spin_lock_irqsave(&host->lock, flags);
918 if (clock && clock == host->clock)
919- return;
920+ goto ret;
921
922 host->mmc->actual_clock = 0;
923
924 if (host->ops->set_clock) {
925+ spin_unlock_irqrestore(&host->lock, flags);
926 host->ops->set_clock(host, clock);
927+ spin_lock_irqsave(&host->lock, flags);
928 if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK)
929- return;
930+ goto ret;
931 }
932
933- sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
934+ if (host->clock)
935+ sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
936
937 if (clock == 0)
938 goto out;
939@@ -1244,12 +1364,12 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
940 }
941
942 clock_set:
943-#if defined(CONFIG_MACH_BCM_FPGA_E)
944- /* Set div = 0 for Java Eve */
945- div = 0;
946-#endif
947 if (real_div)
948 host->mmc->actual_clock = (host->max_clk * clk_mul) / real_div;
949+
950+ if (host->quirks2 & SDHCI_QUIRK2_ALWAYS_USE_BASE_CLOCK)
951+ div = 0;
952+
953 clk |= (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
954 clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
955 << SDHCI_DIVIDER_HI_SHIFT;
956@@ -1257,17 +1377,17 @@ clock_set:
957 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
958
959 /* Wait max 20 ms */
960- timeout = 20;
961+ timeout = 20000;
962 while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
963 & SDHCI_CLOCK_INT_STABLE)) {
964 if (timeout == 0) {
965 pr_err("%s: Internal clock never "
966 "stabilised.\n", mmc_hostname(host->mmc));
967 sdhci_dumpregs(host);
968- return;
969+ goto ret;
970 }
971 timeout--;
972- mdelay(1);
973+ udelay(1);
974 }
975
976 clk |= SDHCI_CLOCK_CARD_EN;
977@@ -1275,15 +1395,21 @@ clock_set:
978
979 out:
980 host->clock = clock;
981+ret:
982+ spin_unlock_irqrestore(&host->lock, flags);
983 }
984
985-static inline void sdhci_update_clock(struct sdhci_host *host)
986+static inline unsigned long sdhci_update_clock(struct sdhci_host *host,
987+ unsigned long flags)
988 {
989 unsigned int clock;
990
991 clock = host->clock;
992 host->clock = 0;
993+ spin_unlock_irqrestore(&host->lock, flags);
994 sdhci_set_clock(host, clock);
995+ spin_lock_irqsave(&host->lock, flags);
996+ return flags;
997 }
998
999 static int sdhci_set_power(struct sdhci_host *host, unsigned short power)
1000@@ -1315,6 +1441,8 @@ static int sdhci_set_power(struct sdhci_host *host, unsigned short power)
1001
1002 if (pwr == 0) {
1003 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1004+ if (host->ops->check_power_status)
1005+ host->ops->check_power_status(host, REQ_BUS_OFF);
1006 return 0;
1007 }
1008
1009@@ -1322,19 +1450,27 @@ static int sdhci_set_power(struct sdhci_host *host, unsigned short power)
1010 * Spec says that we should clear the power reg before setting
1011 * a new value. Some controllers don't seem to like this though.
1012 */
1013- if (!(host->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
1014+ if (!(host->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE)) {
1015 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1016+ if (host->ops->check_power_status)
1017+ host->ops->check_power_status(host, REQ_BUS_OFF);
1018+ }
1019
1020 /*
1021 * At least the Marvell CaFe chip gets confused if we set the voltage
1022 * and set turn on power at the same time, so set the voltage first.
1023 */
1024- if (host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER)
1025+ if (host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER) {
1026 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1027+ if (host->ops->check_power_status)
1028+ host->ops->check_power_status(host, REQ_BUS_ON);
1029+ }
1030
1031 pwr |= SDHCI_POWER_ON;
1032
1033 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1034+ if (host->ops->check_power_status)
1035+ host->ops->check_power_status(host, REQ_BUS_ON);
1036
1037 /*
1038 * Some controllers need an extra 10ms delay of 10ms before they
1039@@ -1346,12 +1482,209 @@ static int sdhci_set_power(struct sdhci_host *host, unsigned short power)
1040 return power;
1041 }
1042
1043+#ifdef CONFIG_SMP
1044+static void sdhci_set_pmqos_req_type(struct sdhci_host *host, bool enable)
1045+{
1046+ /*
1047+ * The default request type PM_QOS_REQ_ALL_CORES is
1048+ * applicable to all CPU cores that are online and
1049+ * this would have a power impact when there are more
1050+ * number of CPUs. This new PM_QOS_REQ_AFFINE_IRQ request
1051+ * type shall update/apply the vote only to that CPU to
1052+ * which this IRQ's affinity is set to.
1053+ * PM_QOS_REQ_AFFINE_CORES request type is used for targets that have
1054+ * big/little architecture and will update/apply the vote to all the
1055+ * cores in the respective cluster.
1056+ */
1057+ if (host->pm_qos_req_dma.type == PM_QOS_REQ_AFFINE_IRQ) {
1058+ host->pm_qos_req_dma.irq = host->irq;
1059+ } else if (host->pm_qos_req_dma.type == PM_QOS_REQ_AFFINE_CORES) {
1060+ if (enable) {
1061+ if (current_thread_info()->cpu < 4)
1062+ host->pm_qos_index = SDHCI_LITTLE_CLUSTER;
1063+ else
1064+ host->pm_qos_index = SDHCI_BIG_CLUSTER;
1065+ }
1066+ cpumask_bits(&host->pm_qos_req_dma.cpus_affine)[0] =
1067+ host->cpu_affinity_mask[host->pm_qos_index];
1068+ }
1069+}
1070+#else
1071+static void sdhci_set_pmqos_req_type(struct sdhci_host *host, bool enable)
1072+{
1073+}
1074+#endif
1075+
1076 /*****************************************************************************\
1077 * *
1078 * MMC callbacks *
1079 * *
1080 \*****************************************************************************/
1081
1082+static int sdhci_enable(struct mmc_host *mmc)
1083+{
1084+ struct sdhci_host *host = mmc_priv(mmc);
1085+
1086+ if (unlikely(!host->cpu_dma_latency_us))
1087+ goto platform_bus_vote;
1088+
1089+ if (host->cpu_dma_latency_tbl_sz > 2)
1090+ host->pm_qos_index = host->power_policy;
1091+
1092+ sdhci_set_pmqos_req_type(host, true);
1093+ pm_qos_update_request(&host->pm_qos_req_dma,
1094+ host->cpu_dma_latency_us[host->pm_qos_index]);
1095+
1096+platform_bus_vote:
1097+ if (host->ops->platform_bus_voting)
1098+ host->ops->platform_bus_voting(host, 1);
1099+
1100+ return 0;
1101+}
1102+
1103+static int sdhci_disable(struct mmc_host *mmc)
1104+{
1105+ struct sdhci_host *host = mmc_priv(mmc);
1106+
1107+ if (unlikely(!host->cpu_dma_latency_us))
1108+ goto platform_bus_vote;
1109+
1110+ if (host->cpu_dma_latency_tbl_sz > 2)
1111+ host->pm_qos_index = host->power_policy;
1112+
1113+ sdhci_set_pmqos_req_type(host, false);
1114+ /*
1115+ * In performance mode, release QoS vote after a timeout to
1116+ * make sure back-to-back requests don't suffer from latencies
1117+ * that are involved to wake CPU from low power modes in cases
1118+ * where the CPU goes into low power mode as soon as QoS vote is
1119+ * released.
1120+ */
1121+ if (host->power_policy == SDHCI_POWER_SAVE_MODE)
1122+ pm_qos_update_request(&host->pm_qos_req_dma,
1123+ PM_QOS_DEFAULT_VALUE);
1124+ else
1125+ pm_qos_update_request_timeout(&host->pm_qos_req_dma,
1126+ host->cpu_dma_latency_us[host->pm_qos_index],
1127+ host->pm_qos_timeout_us);
1128+
1129+platform_bus_vote:
1130+ if (host->ops->platform_bus_voting)
1131+ host->ops->platform_bus_voting(host, 0);
1132+
1133+ return 0;
1134+}
1135+
1136+static inline void sdhci_update_power_policy(struct sdhci_host *host,
1137+ enum sdhci_power_policy policy)
1138+{
1139+ host->power_policy = policy;
1140+}
1141+
1142+static int sdhci_notify_load(struct mmc_host *mmc, enum mmc_load state)
1143+{
1144+ int err = 0;
1145+ struct sdhci_host *host = mmc_priv(mmc);
1146+
1147+ switch (state) {
1148+ case MMC_LOAD_HIGH:
1149+ sdhci_update_power_policy(host, SDHCI_PERFORMANCE_MODE);
1150+ break;
1151+ case MMC_LOAD_LOW:
1152+ sdhci_update_power_policy(host, SDHCI_POWER_SAVE_MODE);
1153+ break;
1154+ default:
1155+ err = -EINVAL;
1156+ break;
1157+ }
1158+
1159+ return err;
1160+}
1161+
1162+static void sdhci_pre_req(struct mmc_host *mmc, struct mmc_request *mrq,
1163+ bool is_first_req)
1164+{
1165+ struct sdhci_host *host = mmc_priv(mmc);
1166+
1167+ if (mrq->data->host_cookie) {
1168+ mrq->data->host_cookie = 0;
1169+ return;
1170+ }
1171+
1172+ if (host->flags & SDHCI_REQ_USE_DMA)
1173+ if (sdhci_pre_dma_transfer(host, mrq->data, &host->next_data) < 0)
1174+ mrq->data->host_cookie = 0;
1175+}
1176+
1177+static void sdhci_post_req(struct mmc_host *mmc, struct mmc_request *mrq,
1178+ int err)
1179+{
1180+ struct sdhci_host *host = mmc_priv(mmc);
1181+ struct mmc_data *data = mrq->data;
1182+
1183+ if (host->flags & SDHCI_REQ_USE_DMA) {
1184+ dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
1185+ (data->flags & MMC_DATA_WRITE) ?
1186+ DMA_TO_DEVICE : DMA_FROM_DEVICE);
1187+ data->host_cookie = 0;
1188+ }
1189+}
1190+
1191+static bool sdhci_check_state(struct sdhci_host *host)
1192+{
1193+ struct mmc_host *mmc = host->mmc;
1194+
1195+ if (!host->clock || !host->pwr ||
1196+ (mmc_use_core_runtime_pm(mmc) ?
1197+ pm_runtime_suspended(mmc->parent) : 0))
1198+ return true;
1199+ else
1200+ return false;
1201+}
1202+
1203+static bool sdhci_check_auto_tuning(struct sdhci_host *host,
1204+ struct mmc_command *cmd)
1205+{
1206+ if (((cmd->opcode != MMC_READ_SINGLE_BLOCK) &&
1207+ (cmd->opcode != MMC_READ_MULTIPLE_BLOCK) &&
1208+ (cmd->opcode != SD_IO_RW_EXTENDED)) || (host->clock < 100000000))
1209+ return false;
1210+ else if (host->mmc->ios.timing == MMC_TIMING_MMC_HS200 ||
1211+ host->mmc->ios.timing == MMC_TIMING_UHS_SDR104)
1212+ return true;
1213+ else
1214+ return false;
1215+}
1216+
1217+static int sdhci_get_tuning_cmd(struct sdhci_host *host)
1218+{
1219+ if (!host->mmc || !host->mmc->card)
1220+ return 0;
1221+ /*
1222+ * If we are here, all conditions have already been true
1223+ * and the card can either be an eMMC or SD/SDIO
1224+ */
1225+ if (mmc_card_mmc(host->mmc->card))
1226+ return MMC_SEND_TUNING_BLOCK_HS200;
1227+ else
1228+ return MMC_SEND_TUNING_BLOCK;
1229+}
1230+
1231+void sdhci_cfg_irq(struct sdhci_host *host, bool enable, bool sync)
1232+{
1233+ if (enable && !host->irq_enabled) {
1234+ enable_irq(host->irq);
1235+ host->irq_enabled = true;
1236+ } else if (!enable && host->irq_enabled) {
1237+ if (sync)
1238+ disable_irq(host->irq);
1239+ else
1240+ disable_irq_nosync(host->irq);
1241+ host->irq_enabled = false;
1242+ }
1243+}
1244+EXPORT_SYMBOL(sdhci_cfg_irq);
1245+
1246 static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
1247 {
1248 struct sdhci_host *host;
1249@@ -1362,6 +1695,33 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
1250 host = mmc_priv(mmc);
1251
1252 sdhci_runtime_pm_get(host);
1253+ if (sdhci_check_state(host)) {
1254+ sdhci_dump_state(host);
1255+ WARN(1, "sdhci in bad state");
1256+ mrq->cmd->error = -EIO;
1257+ if (mrq->data)
1258+ mrq->data->error = -EIO;
1259+ mmc_request_done(host->mmc, mrq);
1260+ sdhci_runtime_pm_put(host);
1261+ return;
1262+ }
1263+
1264+ /*
1265+ * Firstly check card presence from cd-gpio. The return could
1266+ * be one of the following possibilities:
1267+ * negative: cd-gpio is not available
1268+ * zero: cd-gpio is used, and card is removed
1269+ * one: cd-gpio is used, and card is present
1270+ */
1271+ present = mmc_gpio_get_cd(host->mmc);
1272+ if (present < 0) {
1273+ /* If polling, assume that the card is always present. */
1274+ if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
1275+ present = 1;
1276+ else
1277+ present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
1278+ SDHCI_CARD_PRESENT;
1279+ }
1280
1281 spin_lock_irqsave(&host->lock, flags);
1282
1283@@ -1384,40 +1744,22 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
1284
1285 host->mrq = mrq;
1286
1287- /*
1288- * Firstly check card presence from cd-gpio. The return could
1289- * be one of the following possibilities:
1290- * negative: cd-gpio is not available
1291- * zero: cd-gpio is used, and card is removed
1292- * one: cd-gpio is used, and card is present
1293- */
1294- present = mmc_gpio_get_cd(host->mmc);
1295- if (present < 0) {
1296- /* If polling, assume that the card is always present. */
1297- if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
1298- present = 1;
1299- else
1300- present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
1301- SDHCI_CARD_PRESENT;
1302- }
1303-
1304 if (!present || host->flags & SDHCI_DEVICE_DEAD) {
1305 host->mrq->cmd->error = -ENOMEDIUM;
1306 tasklet_schedule(&host->finish_tasklet);
1307 } else {
1308 u32 present_state;
1309
1310- /* Enable CMD/DATA interrupts */
1311- sdhci_unmask_irqs(host, SDHCI_INT_CMD_MASK |
1312- SDHCI_INT_DATA_MASK);
1313-
1314 present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
1315 /*
1316 * Check if the re-tuning timer has already expired and there
1317 * is no on-going data transfer. If so, we need to execute
1318 * tuning procedure before sending command.
1319 */
1320- if ((host->flags & SDHCI_NEEDS_RETUNING) &&
1321+ if ((mrq->cmd->opcode != MMC_SEND_TUNING_BLOCK) &&
1322+ (mrq->cmd->opcode != MMC_SEND_TUNING_BLOCK_HS400) &&
1323+ (mrq->cmd->opcode != MMC_SEND_TUNING_BLOCK_HS200) &&
1324+ (host->flags & SDHCI_NEEDS_RETUNING) &&
1325 !(present_state & (SDHCI_DOING_WRITE | SDHCI_DOING_READ))) {
1326 if (mmc->card) {
1327 /* eMMC uses cmd21 but sd and sdio use cmd19 */
1328@@ -1425,6 +1767,8 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
1329 mmc->card->type == MMC_TYPE_MMC ?
1330 MMC_SEND_TUNING_BLOCK_HS200 :
1331 MMC_SEND_TUNING_BLOCK;
1332+ host->mrq = NULL;
1333+ host->flags &= ~SDHCI_NEEDS_RETUNING;
1334 spin_unlock_irqrestore(&host->lock, flags);
1335 sdhci_execute_tuning(mmc, tuning_opcode);
1336 spin_lock_irqsave(&host->lock, flags);
1337@@ -1434,71 +1778,133 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
1338 }
1339 }
1340
1341+ if (host->ops->config_auto_tuning_cmd) {
1342+ if (sdhci_check_auto_tuning(host, mrq->cmd))
1343+ host->ops->config_auto_tuning_cmd(host, true,
1344+ sdhci_get_tuning_cmd(host));
1345+ else
1346+ host->ops->config_auto_tuning_cmd(host, false,
1347+ sdhci_get_tuning_cmd(host));
1348+ }
1349+
1350 if (mrq->sbc && !(host->flags & SDHCI_AUTO_CMD23))
1351 sdhci_send_command(host, mrq->sbc);
1352 else
1353 sdhci_send_command(host, mrq->cmd);
1354 }
1355+
1356 mmiowb();
1357 spin_unlock_irqrestore(&host->lock, flags);
1358 }
1359
1360+static void sdhci_cfg_async_intr(struct sdhci_host *host, bool enable)
1361+{
1362+ if (!host->async_int_supp)
1363+ return;
1364+
1365+ if (enable)
1366+ sdhci_writew(host,
1367+ sdhci_readw(host, SDHCI_HOST_CONTROL2) |
1368+ SDHCI_CTRL_ASYNC_INT_ENABLE,
1369+ SDHCI_HOST_CONTROL2);
1370+ else
1371+ sdhci_writew(host, sdhci_readw(host, SDHCI_HOST_CONTROL2) &
1372+ ~SDHCI_CTRL_ASYNC_INT_ENABLE,
1373+ SDHCI_HOST_CONTROL2);
1374+}
1375+
1376 static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1377 {
1378 unsigned long flags;
1379 int vdd_bit = -1;
1380 u8 ctrl;
1381+ int ret;
1382
1383- spin_lock_irqsave(&host->lock, flags);
1384-
1385+ mutex_lock(&host->ios_mutex);
1386 if (host->flags & SDHCI_DEVICE_DEAD) {
1387- spin_unlock_irqrestore(&host->lock, flags);
1388 if (host->vmmc && ios->power_mode == MMC_POWER_OFF)
1389 mmc_regulator_set_ocr(host->mmc, host->vmmc, 0);
1390- if (host->ops->set_regulator &&
1391- ios->power_mode == MMC_POWER_OFF) {
1392- pr_info("sdhci_do_set_ios SDHCI_DEVICE_DEAD\n");
1393- host->ops->set_regulator(host, 0);
1394- }
1395+ mutex_unlock(&host->ios_mutex);
1396 return;
1397 }
1398
1399+ spin_lock_irqsave(&host->lock, flags);
1400+ /* lock is being released intermittently below, hence disable irq */
1401+ sdhci_cfg_irq(host, false, false);
1402+ spin_unlock_irqrestore(&host->lock, flags);
1403+ if (ios->clock) {
1404+ sdhci_set_clock(host, ios->clock);
1405+ if (host->async_int_supp && sdhci_get_async_int_status(host)) {
1406+ if (host->disable_sdio_irq_deferred) {
1407+ pr_debug("%s: %s: disable sdio irq\n",
1408+ mmc_hostname(host->mmc), __func__);
1409+ host->mmc->ops->enable_sdio_irq(host->mmc, 0);
1410+ host->disable_sdio_irq_deferred = false;
1411+ }
1412+ spin_lock_irqsave(&host->lock, flags);
1413+ sdhci_cfg_async_intr(host, false);
1414+ spin_unlock_irqrestore(&host->lock, flags);
1415+ pr_debug("%s: %s: unconfig async intr\n",
1416+ mmc_hostname(host->mmc), __func__);
1417+ }
1418+ }
1419 /*
1420- * Reset the chip on each power off.
1421- * Should clear out any weird states.
1422+ * The controller clocks may be off during power-up and we may end up
1423+ * enabling card clock before giving power to the card. Hence, during
1424+ * MMC_POWER_UP enable the controller clock and turn-on the regulators.
1425+ * The mmc_power_up would provide the necessary delay before turning on
1426+ * the clocks to the card.
1427 */
1428- if (ios->power_mode == MMC_POWER_OFF) {
1429- sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
1430- sdhci_reinit(host);
1431+ if (ios->power_mode & MMC_POWER_UP) {
1432+ if (host->ops->enable_controller_clock) {
1433+ ret = host->ops->enable_controller_clock(host);
1434+ if (ret) {
1435+ pr_err("%s: enabling controller clock: failed: %d\n",
1436+ mmc_hostname(host->mmc), ret);
1437+ } else {
1438+ vdd_bit = sdhci_set_power(host, ios->vdd);
1439+
1440+ if (host->vmmc && vdd_bit != -1)
1441+ mmc_regulator_set_ocr(host->mmc,
1442+ host->vmmc,
1443+ vdd_bit);
1444+ }
1445+ }
1446+ /*
1447+ * make sure interrupts are enabled, these are the same
1448+ * interrupts which get enabled in sdhci_init().
1449+ */
1450+ sdhci_clear_set_irqs(host, 0,
1451+ SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT |
1452+ SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_TIMEOUT |
1453+ SDHCI_INT_INDEX |
1454+ SDHCI_INT_END_BIT | SDHCI_INT_CRC | SDHCI_INT_TIMEOUT |
1455+ SDHCI_INT_DATA_END | SDHCI_INT_RESPONSE |
1456+ SDHCI_INT_AUTO_CMD_ERR);
1457 }
1458+ spin_lock_irqsave(&host->lock, flags);
1459+ if (!host->clock) {
1460+ sdhci_cfg_irq(host, true, false);
1461+ spin_unlock_irqrestore(&host->lock, flags);
1462+ mutex_unlock(&host->ios_mutex);
1463+ return;
1464+ }
1465+ spin_unlock_irqrestore(&host->lock, flags);
1466
1467 if (host->version >= SDHCI_SPEC_300 &&
1468 (ios->power_mode == MMC_POWER_UP))
1469 sdhci_enable_preset_value(host, false);
1470
1471- if (ios->power_mode == MMC_POWER_OFF)
1472- vdd_bit = sdhci_set_power(host, -1);
1473- else
1474+ if (!host->ops->enable_controller_clock && (ios->power_mode &
1475+ (MMC_POWER_UP |
1476+ MMC_POWER_ON))) {
1477 vdd_bit = sdhci_set_power(host, ios->vdd);
1478
1479- if (host->vmmc && vdd_bit != -1) {
1480- spin_unlock_irqrestore(&host->lock, flags);
1481- mmc_regulator_set_ocr(host->mmc, host->vmmc, vdd_bit);
1482- spin_lock_irqsave(&host->lock, flags);
1483+ if (host->vmmc && vdd_bit != -1)
1484+ mmc_regulator_set_ocr(host->mmc, host->vmmc, vdd_bit);
1485 }
1486- if (host->ops->set_regulator && vdd_bit != -1) {
1487- spin_unlock_irqrestore(&host->lock, flags);
1488-
1489- if (vdd_bit)
1490- host->ops->set_regulator(host, 1);
1491- else
1492- host->ops->set_regulator(host, 0);
1493-
1494- spin_lock_irqsave(&host->lock, flags);
1495- }
1496-
1497- sdhci_set_clock(host, ios->clock);
1498
1499+ spin_lock_irqsave(&host->lock, flags);
1500 if (host->ops->platform_send_init_74_clocks)
1501 host->ops->platform_send_init_74_clocks(host, ios->power_mode);
1502
1503@@ -1533,8 +1939,8 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1504 && !(host->quirks & SDHCI_QUIRK_NO_HISPD_BIT))
1505 ctrl |= SDHCI_CTRL_HISPD;
1506 #ifdef CONFIG_MMC_BCM_SD
1507- else if (ios->timing == MMC_TIMING_MMC_HS)
1508- ctrl |= SDHCI_CTRL_HISPD;
1509+ else if (ios->timing == MMC_TIMING_MMC_HS)
1510+ ctrl |= SDHCI_CTRL_HISPD;
1511 #endif
1512 else
1513 ctrl &= ~SDHCI_CTRL_HISPD;
1514@@ -1542,21 +1948,15 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1515 if (host->version >= SDHCI_SPEC_300) {
1516 u16 clk, ctrl_2;
1517
1518- /* MM Chipit FPGA does not seem to run with High speed bit enabled. Peri image runs
1519- * fine. Hence disable if its MM image */
1520 /* In case of UHS-I modes, set High Speed Enable */
1521- if ((ios->timing == MMC_TIMING_MMC_HS200) ||
1522+ if ((ios->timing == MMC_TIMING_MMC_HS400) ||
1523+ (ios->timing == MMC_TIMING_MMC_HS200) ||
1524 (ios->timing == MMC_TIMING_UHS_SDR50) ||
1525 (ios->timing == MMC_TIMING_UHS_SDR104) ||
1526 (ios->timing == MMC_TIMING_UHS_DDR50) ||
1527 (ios->timing == MMC_TIMING_UHS_SDR25))
1528 ctrl |= SDHCI_CTRL_HISPD;
1529
1530-#ifdef CONFIG_MACH_BCM_FPGA
1531- if (host->quirks2 & SDHCI_QUIRK2_HOST_MASK_HS_BIT)
1532- ctrl &= ~SDHCI_CTRL_HISPD;
1533-#endif
1534-
1535 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1536 if (!(ctrl_2 & SDHCI_CTRL_PRESET_VAL_ENABLE)) {
1537 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1538@@ -1587,10 +1987,10 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1539 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1540
1541 /* Re-enable SD Clock */
1542- sdhci_update_clock(host);
1543+ if (ios->clock)
1544+ flags = sdhci_update_clock(host, flags);
1545 }
1546
1547-
1548 /* Reset SD Clock Enable */
1549 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1550 clk &= ~SDHCI_CLOCK_CARD_EN;
1551@@ -1602,7 +2002,9 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1552 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1553 /* Select Bus Speed Mode for host */
1554 ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
1555- if (ios->timing == MMC_TIMING_MMC_HS200)
1556+ if (ios->timing == MMC_TIMING_MMC_HS400)
1557+ ctrl_2 |= SDHCI_CTRL_HS_SDR200;
1558+ else if (ios->timing == MMC_TIMING_MMC_HS200)
1559 ctrl_2 |= SDHCI_CTRL_HS_SDR200;
1560 else if (ios->timing == MMC_TIMING_UHS_SDR12)
1561 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
1562@@ -1632,22 +2034,24 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1563 }
1564
1565 /* Re-enable SD Clock */
1566- sdhci_update_clock(host);
1567+ if (ios->clock)
1568+ flags = sdhci_update_clock(host, flags);
1569 } else
1570 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1571
1572+ spin_unlock_irqrestore(&host->lock, flags);
1573 #ifdef CONFIG_BCM_SDIOWL // BROADCOM MODIFICATION
1574- if (ios->host_reset) {
1575- unsigned char reset_flags = 0;
1576- if (ios->host_reset & MMC_HOST_RESET_CMD) {
1577- reset_flags |= SDHCI_RESET_CMD;
1578- }
1579- if (ios->host_reset & MMC_HOST_RESET_DAT) {
1580- reset_flags |= SDHCI_RESET_DATA;
1581- }
1582- printk(KERN_INFO "%s: performing host reset\n", mmc_hostname(host->mmc));
1583- sdhci_reset(host, reset_flags);
1584- }
1585+ if (ios->host_reset) {
1586+ unsigned char reset_flags = 0;
1587+ if (ios->host_reset & MMC_HOST_RESET_CMD) {
1588+ reset_flags |= SDHCI_RESET_CMD;
1589+ }
1590+ if (ios->host_reset & MMC_HOST_RESET_DAT) {
1591+ reset_flags |= SDHCI_RESET_DATA;
1592+ }
1593+ printk(KERN_INFO "%s: performing host reset\n", mmc_hostname(host->mmc));
1594+ sdhci_reset(host, reset_flags);
1595+ }
1596 #endif // BROADCOM MODIFICATION
1597
1598 /*
1599@@ -1658,8 +2062,47 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1600 if(host->quirks & SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS)
1601 sdhci_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
1602
1603- mmiowb();
1604+ /*
1605+ * Reset the chip on each power off.
1606+ * Should clear out any weird states.
1607+ */
1608+ if (ios->power_mode == MMC_POWER_OFF) {
1609+ sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
1610+ sdhci_reinit(host);
1611+ vdd_bit = sdhci_set_power(host, -1);
1612+ if (host->vmmc && vdd_bit != -1)
1613+ mmc_regulator_set_ocr(host->mmc, host->vmmc, vdd_bit);
1614+ if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
1615+ (host->mmc->caps & MMC_CAP_NONREMOVABLE)) {
1616+ /* clear all the pending interrupts */
1617+ sdhci_writel(host, sdhci_readl(host, SDHCI_INT_STATUS),
1618+ SDHCI_INT_STATUS);
1619+ sdhci_mask_irqs(host, SDHCI_INT_ALL_MASK);
1620+ }
1621+ }
1622+ if (!ios->clock) {
1623+ if (host->async_int_supp && host->mmc->card &&
1624+ mmc_card_sdio(host->mmc->card)) {
1625+ sdhci_cfg_async_intr(host, true);
1626+ pr_debug("%s: %s: config async intr\n",
1627+ mmc_hostname(host->mmc), __func__);
1628+ }
1629+ sdhci_set_clock(host, ios->clock);
1630+ }
1631+
1632+ if (ios->power_mode == MMC_POWER_OFF) {
1633+ /* Keep interrupt line disabled as card is anyway powered off */
1634+ if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
1635+ (host->mmc->caps & MMC_CAP_NONREMOVABLE))
1636+ goto out;
1637+ }
1638+
1639+ spin_lock_irqsave(&host->lock, flags);
1640+ sdhci_cfg_irq(host, true, false);
1641 spin_unlock_irqrestore(&host->lock, flags);
1642+out:
1643+ mmiowb();
1644+ mutex_unlock(&host->ios_mutex);
1645 }
1646
1647 static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
1648@@ -1679,14 +2122,20 @@ static int sdhci_do_get_cd(struct sdhci_host *host)
1649 return 0;
1650
1651 /* If polling/nonremovable, assume that the card is always present. */
1652- if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
1653- (host->mmc->caps & MMC_CAP_NONREMOVABLE))
1654+ if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
1655 return 1;
1656
1657- /* Try slot gpio detect */
1658+ /*
1659+ * Try slot gpio detect before checking for the broken card detection
1660+ * quirk. There might be hosts that might have broken card detection
1661+ * but still provide a gpio for card detection.
1662+ */
1663 if (!IS_ERR_VALUE(gpio_cd))
1664 return !!gpio_cd;
1665
1666+ if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
1667+ return 1;
1668+
1669 /* Host native card detect */
1670 return !!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT);
1671 }
1672@@ -1768,6 +2217,14 @@ static void sdhci_enable_sdio_irq_nolock(struct sdhci_host *host, int enable)
1673 if (host->flags & SDHCI_DEVICE_DEAD)
1674 goto out;
1675
1676+ if (!enable && !host->clock) {
1677+ pr_debug("%s: %s: defered disabling card intr\n",
1678+ host->mmc ? mmc_hostname(host->mmc) : "null",
1679+ __func__);
1680+ host->disable_sdio_irq_deferred = true;
1681+ return;
1682+ }
1683+
1684 if (enable)
1685 host->flags |= SDHCI_SDIO_IRQ_ENABLED;
1686 else
1687@@ -1790,19 +2247,16 @@ static void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
1688 struct sdhci_host *host = mmc_priv(mmc);
1689 unsigned long flags;
1690
1691- sdhci_runtime_pm_get(host);
1692 spin_lock_irqsave(&host->lock, flags);
1693 sdhci_enable_sdio_irq_nolock(host, enable);
1694 spin_unlock_irqrestore(&host->lock, flags);
1695- sdhci_runtime_pm_put(host);
1696 }
1697
1698 static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
1699 struct mmc_ios *ios)
1700 {
1701- u16 ctrl;
1702- int ret = -EAGAIN;
1703- u32 present_state;
1704+ u16 ctrl;
1705+ int ret;
1706
1707 /*
1708 * Signal Voltage Switching is only applicable for Host Controllers
1709@@ -1815,80 +2269,63 @@ static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
1710
1711 switch (ios->signal_voltage) {
1712 case MMC_SIGNAL_VOLTAGE_330:
1713- /* Switch VDDO_SDC to 3.3V */
1714- if (host->ops->set_signalling)
1715- ret = host->ops->set_signalling(host,
1716- MMC_SIGNAL_VOLTAGE_330);
1717- if(ret == 0) {
1718-
1719- /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
1720- ctrl &= ~SDHCI_CTRL_VDD_180;
1721- sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1722+ /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
1723+ ctrl &= ~SDHCI_CTRL_VDD_180;
1724+ sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1725+ if (host->ops->check_power_status)
1726+ host->ops->check_power_status(host, REQ_IO_HIGH);
1727
1728- if (host->vqmmc) {
1729- ret = regulator_set_voltage(host->vqmmc, 2700000, 3600000);
1730- if (ret) {
1731- pr_warning("%s: Switching to 3.3V signalling voltage "
1732- " failed\n", mmc_hostname(host->mmc));
1733- return -EIO;
1734- }
1735+ if (host->vqmmc) {
1736+ ret = regulator_set_voltage(host->vqmmc, 2700000, 3600000);
1737+ if (ret) {
1738+ pr_warning("%s: Switching to 3.3V signalling voltage "
1739+ " failed\n", mmc_hostname(host->mmc));
1740+ return -EIO;
1741 }
1742- /* Wait for 5ms */
1743- usleep_range(5000, 5500);
1744+ }
1745+ /* Wait for 5ms */
1746+ usleep_range(5000, 5500);
1747
1748- /* 3.3V regulator output should be stable within 5 ms */
1749- ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1750- if (!(ctrl & SDHCI_CTRL_VDD_180))
1751- return 0;
1752+ /* 3.3V regulator output should be stable within 5 ms */
1753+ ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1754+ if (!(ctrl & SDHCI_CTRL_VDD_180))
1755+ return 0;
1756
1757- pr_warning("%s: 3.3V regulator output did not became stable\n",
1758- mmc_hostname(host->mmc));
1759+ pr_warning("%s: 3.3V regulator output did not became stable\n",
1760+ mmc_hostname(host->mmc));
1761
1762- return -EAGAIN;
1763- } else {
1764- pr_info(DRIVER_NAME ": Switching to 3.3V "
1765- "signalling voltage failed\n");
1766- ret = -EIO;
1767- }
1768+ return -EAGAIN;
1769 case MMC_SIGNAL_VOLTAGE_180:
1770- /* Check whether DAT[3:0] is 0000 */
1771- present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
1772- if (!((present_state & SDHCI_DATA_LVL_MASK) >>
1773- SDHCI_DATA_LVL_SHIFT)) {
1774-
1775- /* Switch VDDO_SDC to 1.8V needed with UHS cards */
1776- if (host->ops->set_signalling)
1777- ret = host->ops->set_signalling(host,
1778- MMC_SIGNAL_VOLTAGE_180);
1779- if (ret == 0) {
1780-
1781- if (host->vqmmc) {
1782- ret = regulator_set_voltage(host->vqmmc,
1783- 1700000, 1950000);
1784- if (ret) {
1785- pr_warning("%s: Switching to 1.8V signalling voltage "
1786- " failed\n", mmc_hostname(host->mmc));
1787- return -EIO;
1788- }
1789- }
1790+ if (host->vqmmc) {
1791+ ret = regulator_set_voltage(host->vqmmc,
1792+ 1700000, 1950000);
1793+ if (ret) {
1794+ pr_warning("%s: Switching to 1.8V signalling voltage "
1795+ " failed\n", mmc_hostname(host->mmc));
1796+ return -EIO;
1797+ }
1798+ }
1799
1800- /*
1801- * Enable 1.8V Signal Enable in the Host Control2
1802- * register
1803- */
1804- ctrl |= SDHCI_CTRL_VDD_180;
1805- sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1806+ /*
1807+ * Enable 1.8V Signal Enable in the Host Control2
1808+ * register
1809+ */
1810+ ctrl |= SDHCI_CTRL_VDD_180;
1811+ sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1812+ if (host->ops->check_power_status)
1813+ host->ops->check_power_status(host, REQ_IO_LOW);
1814
1815- /* Wait for 5ms */
1816- usleep_range(5000, 5500);
1817+ /* Wait for 5ms */
1818+ usleep_range(5000, 5500);
1819+
1820+ /* 1.8V regulator output should be stable within 5 ms */
1821+ ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1822+ if (ctrl & SDHCI_CTRL_VDD_180)
1823+ return 0;
1824+
1825+ pr_warning("%s: 1.8V regulator output did not became stable\n",
1826+ mmc_hostname(host->mmc));
1827
1828- ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1829- if (ctrl & SDHCI_CTRL_VDD_180)
1830- return 0;
1831- }
1832- }
1833- pr_info(DRIVER_NAME ": Switching to 1.8V signalling "
1834- "voltage failed, retrying with S18R set to 0\n");
1835 return -EAGAIN;
1836 case MMC_SIGNAL_VOLTAGE_120:
1837 if (host->vqmmc) {
1838@@ -1937,7 +2374,7 @@ static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
1839 {
1840 struct sdhci_host *host;
1841 u16 ctrl;
1842- u32 ier;
1843+ u32 ier = 0;
1844 int tuning_loop_counter = MAX_TUNING_LOOP;
1845 unsigned long timeout;
1846 int err = 0;
1847@@ -1955,12 +2392,13 @@ static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
1848 * The Host Controller needs tuning only in case of SDR104 mode
1849 * and for SDR50 mode when Use Tuning for SDR50 is set in the
1850 * Capabilities register.
1851- * If the Host Controller supports the HS200 mode then the
1852+ * If the Host Controller supports the HS400/HS200 mode then the
1853 * tuning function has to be executed.
1854 */
1855- if (((ctrl & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
1856- (host->flags & SDHCI_SDR50_NEEDS_TUNING ||
1857- host->flags & SDHCI_HS200_NEEDS_TUNING))
1858+ if ((((ctrl & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
1859+ (host->flags & SDHCI_SDR50_NEEDS_TUNING)) ||
1860+ (host->flags & SDHCI_HS200_NEEDS_TUNING) ||
1861+ (host->flags & SDHCI_HS400_NEEDS_TUNING))
1862 requires_tuning_nonuhs = true;
1863
1864 if (((ctrl & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
1865@@ -1973,6 +2411,14 @@ static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
1866 return 0;
1867 }
1868
1869+ if (host->ops->execute_tuning) {
1870+ spin_unlock(&host->lock);
1871+ enable_irq(host->irq);
1872+ err = host->ops->execute_tuning(host, opcode);
1873+ disable_irq(host->irq);
1874+ spin_lock(&host->lock);
1875+ goto out;
1876+ }
1877 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1878
1879 /*
1880@@ -2015,16 +2461,14 @@ static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
1881 * block to the Host Controller. So we set the block size
1882 * to 64 here.
1883 */
1884- if (cmd.opcode == MMC_SEND_TUNING_BLOCK_HS200) {
1885+ if ((cmd.opcode == MMC_SEND_TUNING_BLOCK_HS400) ||
1886+ (cmd.opcode == MMC_SEND_TUNING_BLOCK_HS200)) {
1887 if (mmc->ios.bus_width == MMC_BUS_WIDTH_8)
1888- sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 128),
1889- SDHCI_BLOCK_SIZE);
1890+ sdhci_set_blk_size_reg(host, 128, 7);
1891 else if (mmc->ios.bus_width == MMC_BUS_WIDTH_4)
1892- sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64),
1893- SDHCI_BLOCK_SIZE);
1894+ sdhci_set_blk_size_reg(host, 64, 7);
1895 } else {
1896- sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64),
1897- SDHCI_BLOCK_SIZE);
1898+ sdhci_set_blk_size_reg(host, 64, 7);
1899 }
1900
1901 /*
1902@@ -2138,6 +2582,9 @@ static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable)
1903 if (host->version < SDHCI_SPEC_300)
1904 return;
1905
1906+ if (host->quirks2 & SDHCI_QUIRK2_BROKEN_PRESET_VALUE)
1907+ return;
1908+
1909 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1910
1911 /*
1912@@ -2159,86 +2606,131 @@ static void sdhci_card_event(struct mmc_host *mmc)
1913 {
1914 struct sdhci_host *host = mmc_priv(mmc);
1915 unsigned long flags;
1916- u16 ctrl;
1917+
1918+ if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
1919+ return;
1920
1921 spin_lock_irqsave(&host->lock, flags);
1922
1923 /* Check host->mrq first in case we are runtime suspended */
1924- if (host->mrq) {
1925- if (sdhci_readl(host, SDHCI_PRESENT_STATE) &
1926- SDHCI_CARD_PRESENT) {
1927- pr_err("%s: Card removed during transfer!\n",
1928- mmc_hostname(host->mmc));
1929- pr_err("%s: Resetting controller.\n",
1930- mmc_hostname(host->mmc));
1931+ if (host->mrq &&
1932+ !(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
1933+ pr_err("%s: Card removed during transfer!\n",
1934+ mmc_hostname(host->mmc));
1935+ pr_err("%s: Resetting controller.\n",
1936+ mmc_hostname(host->mmc));
1937
1938- sdhci_reset(host, SDHCI_RESET_CMD);
1939- sdhci_reset(host, SDHCI_RESET_DATA);
1940+ sdhci_reset(host, SDHCI_RESET_CMD);
1941+ sdhci_reset(host, SDHCI_RESET_DATA);
1942
1943- host->mrq->cmd->error = -ENOMEDIUM;
1944- tasklet_schedule(&host->finish_tasklet);
1945+ host->mrq->cmd->error = -ENOMEDIUM;
1946+ tasklet_schedule(&host->finish_tasklet);
1947+ }
1948
1949- pr_info("SD Card Removed\n");
1950- }
1951+ spin_unlock_irqrestore(&host->lock, flags);
1952+}
1953+
1954+static int sdhci_stop_request(struct mmc_host *mmc)
1955+{
1956+ struct sdhci_host *host = mmc_priv(mmc);
1957+ unsigned long flags;
1958+ struct mmc_data *data;
1959+ int ret = 0;
1960+
1961+ spin_lock_irqsave(&host->lock, flags);
1962+ if (!host->mrq || !host->data) {
1963+ ret = MMC_BLK_NO_REQ_TO_STOP;
1964+ goto out;
1965+ }
1966+
1967+ data = host->data;
1968
1969 #ifdef CONFIG_MMC_BCM_SD
1970- else {
1971- /*
1972- * Though we do the same stuff here as above,
1973- * this is seperated out to deal cleanly with
1974- * merge issues and to make this case exceptional.
1975- */
1976- pr_err("%s: Card removed & inserted during transfer\n",
1977- mmc_hostname(host->mmc));
1978- sdhci_reset(host, SDHCI_RESET_CMD);
1979- sdhci_reset(host, SDHCI_RESET_DATA);
1980+ if (host->mrq) {
1981+ if (sdhci_readl(host, SDHCI_PRESENT_STATE) &
1982+ SDHCI_CARD_PRESENT) {
1983+ }
1984+ else {
1985+ /*
1986+ * Though we do the same stuff here as above,
1987+ * this is seperated out to deal cleanly with
1988+ * merge issues and to make this case exceptional.
1989+ */
1990+ pr_err("%s: Card removed & inserted during transfer\n",
1991+ mmc_hostname(host->mmc));
1992+ sdhci_reset(host, SDHCI_RESET_CMD);
1993+ sdhci_reset(host, SDHCI_RESET_DATA);
1994+
1995+ /*
1996+ * During a request in progress, if we reach here
1997+ * it defenitely means that the card had got removed
1998+ * at least once during the transfer, though the
1999+ * present state says the other way. This can be a
2000+ * case of a person with magically quick fingers
2001+ * performing multiple card insert/removals. The
2002+ * reason why we end up here is because the
2003+ * cd interrupt handler is a "threaded irq".
2004+ */
2005+ host->mrq->cmd->error = -ENOMEDIUM;
2006+ tasklet_schedule(&host->finish_tasklet);
2007+ }
2008+ } else {
2009+ if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) &
2010+ SDHCI_CARD_PRESENT)) {
2011+ pr_info("SD Card Removed\n");
2012+ } else {
2013+ /*
2014+ * Turn ON the SDCLK very early here; We do this
2015+ * to handle the case of quick remove-insert.
2016+ */
2017+ unsigned int clock;
2018+ clock = host->clock;
2019+ host->clock = 0;
2020+ sdhci_set_clock(host, clock);
2021+
2022+ pr_info("SD Card Inserted\n");
2023+ }
2024+ }
2025+#endif
2026
2027- /*
2028- * During a request in progress, if we reach here
2029- * it defenitely means that the card had got removed
2030- * at least once during the transfer, though the
2031- * present state says the other way. This can be a
2032- * case of a person with magically quick fingers
2033- * performing multiple card insert/removals. The
2034- * reason why we end up here is because the
2035- * cd interrupt handler is a "threaded irq".
2036- */
2037- host->mrq->cmd->error = -ENOMEDIUM;
2038- tasklet_schedule(&host->finish_tasklet);
2039- }
2040- } else {
2041- if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) &
2042- SDHCI_CARD_PRESENT)) {
2043- pr_info("SD Card Removed\n");
2044- } else {
2045- /*
2046- * Turn ON the SDCLK very early here; We do this
2047- * to handle the case of quick remove-insert.
2048- */
2049- unsigned int clock;
2050- clock = host->clock;
2051- host->clock = 0;
2052- sdhci_set_clock(host, clock);
2053+ if (host->ops->disable_data_xfer)
2054+ host->ops->disable_data_xfer(host);
2055+
2056+ sdhci_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
2057
2058- pr_info("SD Card Inserted\n");
2059+ if (host->flags & SDHCI_REQ_USE_DMA) {
2060+ if (host->flags & SDHCI_USE_ADMA) {
2061+ sdhci_adma_table_post(host, data);
2062+ } else {
2063+ if (!data->host_cookie)
2064+ dma_unmap_sg(mmc_dev(host->mmc), data->sg,
2065+ data->sg_len,
2066+ (data->flags & MMC_DATA_READ) ?
2067+ DMA_FROM_DEVICE : DMA_TO_DEVICE);
2068 }
2069-#endif
2070 }
2071+ del_timer(&host->timer);
2072+ host->mrq = NULL;
2073+ host->cmd = NULL;
2074+ host->data = NULL;
2075+out:
2076+ spin_unlock_irqrestore(&host->lock, flags);
2077+ return ret;
2078+}
2079
2080- /* Clear EN1P8V of Host Control register 2.
2081- * It is observed that 1.8V signalling fails
2082- * sometimes without this. We make sure
2083- * that SD card is not driven by 1.8V I/O before
2084- * its init
2085- */
2086- ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2087- ctrl &= ~SDHCI_CTRL_VDD_180;
2088- sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2089+static unsigned int sdhci_get_xfer_remain(struct mmc_host *mmc)
2090+{
2091+ struct sdhci_host *host = mmc_priv(mmc);
2092+ u32 present_state = 0;
2093
2094- spin_unlock_irqrestore(&host->lock, flags);
2095+ present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
2096+
2097+ return present_state & SDHCI_DOING_WRITE;
2098 }
2099
2100 static const struct mmc_host_ops sdhci_ops = {
2101+ .pre_req = sdhci_pre_req,
2102+ .post_req = sdhci_post_req,
2103 .request = sdhci_request,
2104 .set_ios = sdhci_set_ios,
2105 .get_cd = sdhci_get_cd,
2106@@ -2249,6 +2741,11 @@ static const struct mmc_host_ops sdhci_ops = {
2107 .execute_tuning = sdhci_execute_tuning,
2108 .card_event = sdhci_card_event,
2109 .card_busy = sdhci_card_busy,
2110+ .enable = sdhci_enable,
2111+ .disable = sdhci_disable,
2112+ .stop_request = sdhci_stop_request,
2113+ .get_xfer_remain = sdhci_get_xfer_remain,
2114+ .notify_load = sdhci_notify_load,
2115 };
2116
2117 /*****************************************************************************\
2118@@ -2263,36 +2760,16 @@ static void sdhci_tasklet_card(unsigned long param)
2119
2120 sdhci_card_event(host->mmc);
2121
2122- /*
2123- * This corresponds to the clock enabled in cd interrupt
2124- * We cant do an autosuspend here. If the card is removed
2125- * the clock may be turned ON forever if the disable is
2126- * delayed.
2127- */
2128-#ifdef CONFIG_LOCKDEP
2129- lockdep_off();
2130-#endif
2131- pm_runtime_put_sync_suspend(host->mmc->parent);
2132-#ifdef CONFIG_LOCKDEP
2133- lockdep_on();
2134-#endif
2135-
2136- /*
2137- * We do this here for reasons stated in the comment
2138- * in card emulate function
2139- */
2140- host->ops->clk_enable(host, 0);
2141-
2142 #ifdef CONFIG_MMC_BCM_SD
2143
2144- /*
2145- * On Java with a delay of 0 results in workqueque
2146- * being run on the same CPU,otherwise this results
2147- * in SD-card getting the device name as mmcblk0
2148- * but for our rpmb driver to work eMMC always
2149- * needs to be mmcblk0
2150- */
2151- mmc_detect_change(host->mmc, msecs_to_jiffies(host->detect_delay));
2152+ /*
2153+ * On Java with a delay of 0 results in workqueque
2154+ * being run on the same CPU,otherwise this results
2155+ * in SD-card getting the device name as mmcblk0
2156+ * but for our rpmb driver to work eMMC always
2157+ * needs to be mmcblk0
2158+ */
2159+ mmc_detect_change(host->mmc, msecs_to_jiffies(host->detect_delay));
2160 #else
2161 mmc_detect_change(host->mmc, msecs_to_jiffies(200));
2162 #endif
2163@@ -2308,9 +2785,6 @@ static void sdhci_tasklet_finish(unsigned long param)
2164
2165 spin_lock_irqsave(&host->lock, flags);
2166
2167- /* Disable CMD/DATA interrupts after request is complete */
2168- sdhci_mask_irqs(host, SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK);
2169-
2170 /*
2171 * If this tasklet gets rescheduled while running, it will
2172 * be run again afterwards but without any active request.
2173@@ -2337,74 +2811,33 @@ static void sdhci_tasklet_finish(unsigned long param)
2174 /* Some controllers need this kick or reset won't work here */
2175 if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET)
2176 /* This is to force an update */
2177- sdhci_update_clock(host);
2178+ flags = sdhci_update_clock(host, flags);
2179
2180- sdhci_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
2181+ /* Spec says we should do both at the same time, but Ricoh
2182+ controllers do not like that. */
2183+ sdhci_reset(host, SDHCI_RESET_CMD);
2184+ sdhci_reset(host, SDHCI_RESET_DATA);
2185+ } else {
2186+ if (host->quirks2 & SDHCI_QUIRK2_RDWR_TX_ACTIVE_EOT)
2187+ sdhci_reset(host, SDHCI_RESET_DATA);
2188 }
2189
2190 host->mrq = NULL;
2191 host->cmd = NULL;
2192 host->data = NULL;
2193+ host->auto_cmd_err_sts = 0;
2194
2195 #ifndef SDHCI_USE_LEDS_CLASS
2196 sdhci_deactivate_led(host);
2197 #endif
2198
2199 mmiowb();
2200-
2201 spin_unlock_irqrestore(&host->lock, flags);
2202
2203 mmc_request_done(host->mmc, mrq);
2204 sdhci_runtime_pm_put(host);
2205 }
2206
2207-/*
2208- * Internal work. Work to wait for the busy signalling to finish. Certain MMC
2209- * operations can take a long time to complete.
2210- */
2211-static void sdhci_work_wait_for_busy(struct work_struct *work)
2212-{
2213- struct sdhci_host *host = container_of(work, struct sdhci_host,
2214- wait_for_busy_work);
2215- int wait_cnt = 0, delay;
2216-
2217- delay = host->cmd->sanitize_busy ? host->cmd->cmd_timeout_ms / 1000 :
2218- SDHCI_MAX_BUSY_WAIT;
2219- mod_timer(&host->timer, jiffies + (delay + 5) * HZ);
2220-
2221- /*
2222- * According to Arasan, when DTOERR occured while CMD38/CMD6,
2223- * which is not treated as normal and as an error by the Host,
2224- * host driver should reset CMD & DATA Lines for SDHC internal state.
2225- */
2226- pr_info("Resetting CMD & DATA Lines at once\n");
2227- sdhci_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
2228-
2229- pr_info("Waiting for BUSY signalling to end\n");
2230- while (wait_cnt++ < (10 * delay) &&
2231- (sdhci_readl(host, SDHCI_PRESENT_STATE) &
2232- SDHCI_DATA_LVL_DAT0_MASK) == 0) {
2233- msleep(100);
2234- }
2235-
2236- if (wait_cnt >= (10 * delay)) {
2237- pr_err("%s: Operation takes too long to finish!\n",
2238- mmc_hostname(host->mmc));
2239- /*
2240- * Set sanitize_busy flag as true so as above stack issues HPI
2241- * to get card out of programming state when timeout occur for
2242- * secure erase (in case of eMMC 4.4.1)
2243- */
2244- host->cmd->sanitize_busy = true;
2245- host->cmd->error = -ETIMEDOUT;
2246- tasklet_schedule(&host->finish_tasklet);
2247- } else {
2248- pr_info("end of BUSY signalling\n");
2249- sdhci_finish_command(host);
2250- }
2251-}
2252-
2253-
2254 static void sdhci_timeout_timer(unsigned long data)
2255 {
2256 struct sdhci_host *host;
2257@@ -2414,14 +2847,22 @@ static void sdhci_timeout_timer(unsigned long data)
2258
2259 spin_lock_irqsave(&host->lock, flags);
2260
2261- host->ops->sdhci_debug(host);
2262-
2263 if (host->mrq) {
2264- pr_err("%s: Timeout waiting for hardware "
2265- "interrupt.\n", mmc_hostname(host->mmc));
2266- sdhci_dumpregs(host);
2267+ if (!host->mrq->cmd->ignore_timeout) {
2268+ pr_err("%s: Timeout waiting for hardware interrupt.\n",
2269+ mmc_hostname(host->mmc));
2270+ if (host->data)
2271+ sdhci_show_adma_error(host);
2272+ else
2273+ sdhci_dumpregs(host);
2274+ }
2275
2276 if (host->data) {
2277+ pr_info("%s: bytes to transfer: %d transferred: %d\n",
2278+ mmc_hostname(host->mmc),
2279+ (host->data->blksz * host->data->blocks),
2280+ (sdhci_readw(host, SDHCI_BLOCK_SIZE) & 0xFFF) *
2281+ sdhci_readw(host, SDHCI_BLOCK_COUNT));
2282 host->data->error = -ETIMEDOUT;
2283 sdhci_finish_data(host);
2284 } else {
2285@@ -2460,6 +2901,8 @@ static void sdhci_tuning_timer(unsigned long data)
2286
2287 static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
2288 {
2289+ u16 auto_cmd_status;
2290+ u32 command;
2291 BUG_ON(intmask == 0);
2292
2293 if (!host->cmd) {
2294@@ -2470,13 +2913,38 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
2295 return;
2296 }
2297
2298+ trace_mmc_cmd_rw_end(host->cmd->opcode, intmask,
2299+ sdhci_readl(host, SDHCI_RESPONSE));
2300+
2301 if (intmask & SDHCI_INT_TIMEOUT)
2302 host->cmd->error = -ETIMEDOUT;
2303 else if (intmask & (SDHCI_INT_CRC | SDHCI_INT_END_BIT |
2304 SDHCI_INT_INDEX))
2305 host->cmd->error = -EILSEQ;
2306
2307+ if (intmask & SDHCI_INT_AUTO_CMD_ERR) {
2308+ auto_cmd_status = host->auto_cmd_err_sts;
2309+ pr_err("%s: %s: AUTO CMD err sts 0x%08x\n",
2310+ mmc_hostname(host->mmc), __func__, auto_cmd_status);
2311+ if (auto_cmd_status & (SDHCI_AUTO_CMD12_NOT_EXEC |
2312+ SDHCI_AUTO_CMD_INDEX_ERR |
2313+ SDHCI_AUTO_CMD_ENDBIT_ERR))
2314+ host->cmd->error = -EIO;
2315+ else if (auto_cmd_status & SDHCI_AUTO_CMD_TIMEOUT_ERR)
2316+ host->cmd->error = -ETIMEDOUT;
2317+ else if (auto_cmd_status & SDHCI_AUTO_CMD_CRC_ERR)
2318+ host->cmd->error = -EILSEQ;
2319+ }
2320+
2321 if (host->cmd->error) {
2322+ command = SDHCI_GET_CMD(sdhci_readw(host,
2323+ SDHCI_COMMAND));
2324+ if (host->cmd->error == -EILSEQ &&
2325+ (command != MMC_SEND_TUNING_BLOCK_HS400) &&
2326+ (command != MMC_SEND_TUNING_BLOCK_HS200) &&
2327+ (command != MMC_SEND_TUNING_BLOCK) &&
2328+ (command != MMC_SEND_STATUS))
2329+ host->flags |= SDHCI_NEEDS_RETUNING;
2330 tasklet_schedule(&host->finish_tasklet);
2331 return;
2332 }
2333@@ -2507,86 +2975,52 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
2334 sdhci_finish_command(host);
2335 }
2336
2337-#ifdef CONFIG_MMC_DEBUG
2338 static void sdhci_show_adma_error(struct sdhci_host *host)
2339 {
2340 const char *name = mmc_hostname(host->mmc);
2341 u8 *desc = host->adma_desc;
2342- __le32 *dma;
2343 __le16 *len;
2344 u8 attr;
2345
2346 sdhci_dumpregs(host);
2347
2348 while (true) {
2349- dma = (__le32 *)(desc + 4);
2350 len = (__le16 *)(desc + 2);
2351 attr = *desc;
2352
2353- DBG("%s: %p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n",
2354- name, desc, le32_to_cpu(*dma), le16_to_cpu(*len), attr);
2355+ if (host->flags & SDHCI_USE_ADMA_64BIT) {
2356+ __le64 *dma = (__le64 *)(desc + 4);
2357+ pr_info("%s: %p: DMA %llx, LEN 0x%04x, Attr=0x%02x\n",
2358+ name, desc, (long long)le64_to_cpu(*dma),
2359+ le16_to_cpu(*len), attr);
2360+ } else {
2361+ __le32 *dma = (__le32 *)(desc + 4);
2362+ pr_info("%s: %p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n",
2363+ name, desc, le32_to_cpu(*dma), le16_to_cpu(*len),
2364+ attr);
2365+ }
2366
2367- desc += 8;
2368+ desc += host->adma_desc_line_sz;
2369
2370 if (attr & 2)
2371 break;
2372 }
2373 }
2374-#else
2375-static void sdhci_show_adma_error(struct sdhci_host *host) { }
2376-#endif
2377-
2378-#ifdef CONFIG_SDHCI_THROUGHPUT
2379-static void sdhci_debugfs_thrpt_calculate(struct sdhci_host *host)
2380-{
2381- struct sdhci_throughput *mmc_thpt;
2382- u8 *rw_str[2] = {"R:", "W:"};
2383- u32 time;
2384- u8 dir;
2385-
2386- if (unlikely(host->thrpt_dbgfs_enable)) {
2387- mmc_thpt = &mmc_throughput[host->mmc->index];
2388- if (mmc_thpt) {
2389- dir = !(mmc_thpt->read & MMC_DATA_READ);
2390- do_gettimeofday(&(mmc_thpt->t2));
2391- time = mmc_thpt->tot_time[dir].tv_usec + \
2392- ((mmc_thpt->t2.tv_sec - \
2393- mmc_thpt->t1.tv_sec) * 1000000) + \
2394- ((int)(mmc_thpt->t2.tv_usec) - \
2395- (int)(mmc_thpt->t1.tv_usec));
2396-
2397- mmc_thpt->tot_time[dir].tv_sec += time / 1000000;
2398- mmc_thpt->tot_time[dir].tv_usec = time % 1000000;
2399-
2400- mmc_thpt->bytes_tx[dir] += (mmc_thpt->nm_of_blks * \
2401- mmc_thpt->blk_size);
2402-
2403- pr_debug("%s(%s) %ld,%ld,%ld,%ld,%ld, %ld, %d,%d %d\n",
2404- rw_str[dir], \
2405- mmc_hostname(host->mmc),
2406- mmc_thpt->t2.tv_sec, mmc_thpt->t2.tv_usec, \
2407- mmc_thpt->t1.tv_sec, mmc_thpt->t1.tv_usec, \
2408- mmc_thpt->tot_time[dir].tv_sec, \
2409- mmc_thpt->tot_time[dir].tv_usec, \
2410- mmc_thpt->blk_size, mmc_thpt->nm_of_blks, \
2411- mmc_thpt->bytes_tx[dir]);
2412- }
2413- }
2414-}
2415-
2416-#endif
2417-
2418
2419 static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
2420 {
2421 u32 command;
2422+ bool pr_msg = false;
2423 BUG_ON(intmask == 0);
2424
2425+ command = SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND));
2426+ trace_mmc_data_rw_end(command, intmask);
2427+
2428 /* CMD19 generates _only_ Buffer Read Ready interrupt */
2429 if (intmask & SDHCI_INT_DATA_AVAIL) {
2430- command = SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND));
2431 if (command == MMC_SEND_TUNING_BLOCK ||
2432- command == MMC_SEND_TUNING_BLOCK_HS200) {
2433+ command == MMC_SEND_TUNING_BLOCK_HS200 ||
2434+ command == MMC_SEND_TUNING_BLOCK_HS400) {
2435 host->tuning_done = 1;
2436 wake_up(&host->buf_ready_int);
2437 return;
2438@@ -2604,67 +3038,16 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
2439 sdhci_finish_command(host);
2440 return;
2441 }
2442-
2443- /*
2444- * Some MMC takes a long time for the erase & certain
2445- * operations to finish. Timeout might be triggered well
2446- * before erase or SWITCH operation finishes. If this
2447- * happens schedule a workqueue work item to monitor
2448- * the DAT0 line to wait for operation to finish.
2449- */
2450- if (intmask & SDHCI_INT_DATA_TIMEOUT &&
2451- (host->cmd->opcode == MMC_ERASE ||
2452- host->cmd->opcode == MMC_SWITCH)) {
2453- if ((sdhci_readl(host, SDHCI_PRESENT_STATE) &
2454- SDHCI_DATA_LVL_DAT0_MASK) == 0) {
2455- schedule_work(&host->wait_for_busy_work);
2456- return;
2457- } else {
2458- sdhci_finish_command(host);
2459- return;
2460- }
2461- }
2462+ if (host->quirks2 &
2463+ SDHCI_QUIRK2_IGNORE_DATATOUT_FOR_R1BCMD)
2464+ return;
2465 }
2466
2467 pr_err("%s: Got data interrupt 0x%08x even "
2468 "though no data operation was in progress.\n",
2469 mmc_hostname(host->mmc), (unsigned)intmask);
2470 sdhci_dumpregs(host);
2471- host->ops->sdhci_debug(host);
2472-
2473- /*
2474- * This condition is hit with some damaged SD card.
2475- * This is wrong trigger of DTOERR when host is processing
2476- * STOP command.
2477- *
2478- * Workaround:
2479- *
2480- * Make sure to complete the request by scheduling
2481- * finish_tasklet. This sends the completion event
2482- * to the upper layers and un-block the mmc_queue_thread.
2483
2484- * Return cmd error -ENOMEDIUM so block layer does not send
2485- * more IO requests in case of damaged card.
2486- *
2487- * Disable command retry as with DTO = 2.8sec,retries = 5,
2488- * mmc_queue_thread would block for more than 10seconds.
2489- *
2490- */
2491- WARN_ON(host->mrq == NULL);
2492- if (host->mrq && host->mrq->data) {
2493- if (host->mrq->data->error) {
2494- printk(KERN_ERR"%s- It is possible that the"
2495- "damaged SD card is inserted-Error:0x%x\n",
2496- mmc_hostname(host->mmc),
2497- host->mrq->data->error);
2498- if (mmc_card_is_removable(host->mmc))
2499- host->mrq->cmd->error = -ENOMEDIUM;
2500- else
2501- host->mrq->cmd->error = -EIO;
2502- host->mrq->cmd->retries = 0;
2503- tasklet_schedule(&host->finish_tasklet);
2504- }
2505- }
2506 return;
2507 }
2508
2509@@ -2673,8 +3056,7 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
2510 else if (intmask & SDHCI_INT_DATA_END_BIT)
2511 host->data->error = -EILSEQ;
2512 else if ((intmask & SDHCI_INT_DATA_CRC) &&
2513- SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND))
2514- != MMC_BUS_TEST_R)
2515+ (command != MMC_BUS_TEST_R))
2516 host->data->error = -EILSEQ;
2517 else if (intmask & SDHCI_INT_ADMA_ERROR) {
2518 pr_err("%s: ADMA error\n", mmc_hostname(host->mmc));
2519@@ -2683,10 +3065,27 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
2520 if (host->ops->adma_workaround)
2521 host->ops->adma_workaround(host, intmask);
2522 }
2523-
2524- if (host->data->error)
2525+ if (host->data->error) {
2526+ if (intmask & (SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_TIMEOUT)) {
2527+ if ((command != MMC_SEND_TUNING_BLOCK_HS400) &&
2528+ (command != MMC_SEND_TUNING_BLOCK_HS200) &&
2529+ (command != MMC_SEND_TUNING_BLOCK)) {
2530+ pr_msg = true;
2531+ if (intmask & SDHCI_INT_DATA_CRC)
2532+ host->flags |= SDHCI_NEEDS_RETUNING;
2533+ }
2534+ } else {
2535+ pr_msg = true;
2536+ }
2537+ if (pr_msg && __ratelimit(&host->dbg_dump_rs)) {
2538+ pr_err("%s: data txfr (0x%08x) error: %d after %lld ms\n",
2539+ mmc_hostname(host->mmc), intmask,
2540+ host->data->error, ktime_to_ms(ktime_sub(
2541+ ktime_get(), host->data_start_time)));
2542+ sdhci_dumpregs(host);
2543+ }
2544 sdhci_finish_data(host);
2545- else {
2546+ } else {
2547 if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL))
2548 sdhci_transfer_pio(host);
2549
2550@@ -2726,9 +3125,6 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
2551 */
2552 host->data_early = 1;
2553 } else {
2554-#ifdef CONFIG_SDHCI_THROUGHPUT
2555- sdhci_debugfs_thrpt_calculate(host);
2556-#endif
2557 sdhci_finish_data(host);
2558 }
2559 }
2560@@ -2751,7 +3147,34 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
2561 return IRQ_HANDLED;
2562 }
2563
2564+ if (!host->clock && host->mmc->card &&
2565+ mmc_card_sdio(host->mmc->card)) {
2566+ /* SDIO async. interrupt is level-sensitive */
2567+ sdhci_cfg_irq(host, false, false);
2568+ pr_debug("%s: got async-irq: clocks: %d gated: %d host-irq[en:1/dis:0]: %d\n",
2569+ mmc_hostname(host->mmc), host->clock,
2570+ host->mmc->clk_gated, host->irq_enabled);
2571+ spin_unlock(&host->lock);
2572+ /* prevent suspend till the ksdioirqd runs or resume happens */
2573+ if ((host->mmc->dev_status == DEV_SUSPENDING) ||
2574+ (host->mmc->dev_status == DEV_SUSPENDED))
2575+ pm_wakeup_event(&host->mmc->card->dev,
2576+ SDHCI_SUSPEND_TIMEOUT);
2577+ else
2578+ mmc_signal_sdio_irq(host->mmc);
2579+ return IRQ_HANDLED;
2580+ } else if (!host->clock) {
2581+ /*
2582+ * As clocks are disabled, controller registers might not be
2583+ * accessible hence return from here.
2584+ */
2585+ pr_err_ratelimited("%s: %s: clocks are disabled !!!\n",
2586+ mmc_hostname(host->mmc), __func__);
2587+ spin_unlock(&host->lock);
2588+ return IRQ_HANDLED;
2589+ }
2590 intmask = sdhci_readl(host, SDHCI_INT_STATUS);
2591+
2592 if (!intmask || intmask == 0xffffffff) {
2593 result = IRQ_NONE;
2594 goto out;
2595@@ -2787,14 +3210,23 @@ again:
2596 }
2597
2598 if (intmask & SDHCI_INT_CMD_MASK) {
2599+ if (intmask & SDHCI_INT_AUTO_CMD_ERR)
2600+ host->auto_cmd_err_sts = sdhci_readw(host,
2601+ SDHCI_AUTO_CMD_ERR);
2602 sdhci_writel(host, intmask & SDHCI_INT_CMD_MASK,
2603 SDHCI_INT_STATUS);
2604+ if ((host->quirks2 & SDHCI_QUIRK2_SLOW_INT_CLR) &&
2605+ (host->clock <= 400000))
2606+ udelay(40);
2607 sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK);
2608 }
2609
2610 if (intmask & SDHCI_INT_DATA_MASK) {
2611 sdhci_writel(host, intmask & SDHCI_INT_DATA_MASK,
2612 SDHCI_INT_STATUS);
2613+ if ((host->quirks2 & SDHCI_QUIRK2_SLOW_INT_CLR) &&
2614+ (host->clock <= 400000))
2615+ udelay(40);
2616 sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK);
2617 }
2618
2619@@ -2836,9 +3268,13 @@ out:
2620 /*
2621 * We have to delay this as it calls back into the driver.
2622 */
2623- if (cardint)
2624+ if (cardint) {
2625+ /* clks are on, but suspend may be in progress */
2626+ if (host->mmc->dev_status == DEV_SUSPENDING)
2627+ pm_wakeup_event(&host->mmc->card->dev,
2628+ SDHCI_SUSPEND_TIMEOUT);
2629 mmc_signal_sdio_irq(host->mmc);
2630-
2631+ }
2632 return result;
2633 }
2634
2635@@ -2879,9 +3315,7 @@ EXPORT_SYMBOL_GPL(sdhci_disable_irq_wakeups);
2636 int sdhci_suspend_host(struct sdhci_host *host)
2637 {
2638 int ret;
2639- struct mmc_host *mmc;
2640
2641- mmc = host->mmc;
2642 if (host->ops->platform_suspend)
2643 host->ops->platform_suspend(host);
2644
2645@@ -2893,9 +3327,6 @@ int sdhci_suspend_host(struct sdhci_host *host)
2646 host->flags &= ~SDHCI_NEEDS_RETUNING;
2647 }
2648
2649- /* Flush and wait for busy operation to complete */
2650- flush_work(&host->wait_for_busy_work);
2651-
2652 ret = mmc_suspend_host(host->mmc);
2653 if (ret) {
2654 if (host->flags & SDHCI_USING_RETUNING_TIMER) {
2655@@ -2923,7 +3354,7 @@ EXPORT_SYMBOL_GPL(sdhci_suspend_host);
2656
2657 int sdhci_resume_host(struct sdhci_host *host)
2658 {
2659- int ret = 0;
2660+ int ret;
2661
2662 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
2663 if (host->ops->enable_dma)
2664@@ -2972,19 +3403,19 @@ EXPORT_SYMBOL_GPL(sdhci_resume_host);
2665
2666 static int sdhci_runtime_pm_get(struct sdhci_host *host)
2667 {
2668- if (host->ops->rpm_enabled(host))
2669+ if (!mmc_use_core_runtime_pm(host->mmc))
2670 return pm_runtime_get_sync(host->mmc->parent);
2671 else
2672- return host->ops->clk_enable(host, 1);
2673+ return 0;
2674 }
2675
2676 static int sdhci_runtime_pm_put(struct sdhci_host *host)
2677 {
2678- if (host->ops->rpm_enabled(host)) {
2679+ if (!mmc_use_core_runtime_pm(host->mmc)) {
2680 pm_runtime_mark_last_busy(host->mmc->parent);
2681 return pm_runtime_put_autosuspend(host->mmc->parent);
2682 } else {
2683- return host->ops->clk_enable(host, 0);
2684+ return 0;
2685 }
2686 }
2687
2688@@ -3082,149 +3513,32 @@ struct sdhci_host *sdhci_alloc_host(struct device *dev,
2689 host = mmc_priv(mmc);
2690 host->mmc = mmc;
2691
2692+ spin_lock_init(&host->lock);
2693+ mutex_init(&host->ios_mutex);
2694+ ratelimit_state_init(&host->dbg_dump_rs, SDHCI_DBG_DUMP_RS_INTERVAL,
2695+ SDHCI_DBG_DUMP_RS_BURST);
2696+
2697 return host;
2698 }
2699
2700 EXPORT_SYMBOL_GPL(sdhci_alloc_host);
2701
2702-#ifdef CONFIG_SDHCI_THROUGHPUT
2703-
2704-static int sdhci_debugfs_get_thrput(void *data, u64 *val)
2705+#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
2706+static int sdhci_is_adma2_64bit(struct sdhci_host *host)
2707 {
2708- struct sdhci_host *host = data;
2709- struct sdhci_throughput *mmc_thpt;
2710- u64 thrput = 0;
2711- u32 time = 0;
2712- u8 *rw_str[2] = {"R:", "W:"};
2713- u8 dir;
2714-
2715- mmc_thpt = &mmc_throughput[host->mmc->index];
2716+ u32 caps;
2717
2718- if (mmc_thpt->dir & (MMC_DATA_READ|MMC_DATA_WRITE)) {
2719- dir = !(mmc_thpt->dir & MMC_DATA_READ);
2720- time = ((mmc_thpt->tot_time[dir].tv_sec * 1000000) + \
2721- mmc_thpt->tot_time[dir].tv_usec);
2722- if (time) {
2723- pr_debug("%s(%s)bytes = %u,time = %u(usec)\n",
2724- rw_str[dir], mmc_hostname(host->mmc),
2725- mmc_thpt->bytes_tx[dir], time);
2726- thrput = ((u64)mmc_thpt->bytes_tx[dir] * 1000000);
2727- do_div(thrput, time);
2728- }
2729- *val = thrput;
2730- } else {
2731- *val = 0;
2732- }
2733+ caps = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ? host->caps :
2734+ sdhci_readl(host, SDHCI_CAPABILITIES);
2735
2736+ if (caps & SDHCI_CAN_64BIT)
2737+ return 1;
2738 return 0;
2739 }
2740-/* Write '0' to clear the readings.
2741- Write '1' to get the read throughput
2742- write '2' to get the write throughput
2743- */
2744-static int sdhci_debugfs_set_thrput(void *data, u64 val)
2745-{
2746- struct sdhci_host *host = data;
2747- struct sdhci_throughput *mmc_thpt;
2748-
2749- mmc_thpt = &mmc_throughput[host->mmc->index];
2750-
2751- mmc_thpt->dir = 0;
2752- pr_debug("%s=%llu\n", __func__, val);
2753- switch (val) {
2754- case 0:
2755- mmc_thpt->bytes_tx[0] = 0;
2756- mmc_thpt->tot_time[0].tv_sec = 0;
2757- mmc_thpt->tot_time[0].tv_usec = 0;
2758- mmc_thpt->bytes_tx[1] = 0;
2759- mmc_thpt->tot_time[1].tv_sec = 0;
2760- mmc_thpt->tot_time[1].tv_usec = 0;
2761- break;
2762- case 1:
2763- mmc_thpt->dir = MMC_DATA_READ;
2764- break;
2765- case 2:
2766- mmc_thpt->dir = MMC_DATA_WRITE;
2767- break;
2768- default:
2769- printk(KERN_ERR "Value not Supported\n");
2770- break;
2771- }
2772- return 0;
2773-}
2774-
2775-DEFINE_SIMPLE_ATTRIBUTE(sdhci_thrpt_fops, sdhci_debugfs_get_thrput,
2776- sdhci_debugfs_set_thrput, "%llu\n");
2777-
2778-
2779-static void sdhci_debugfs_throughput_remove(struct sdhci_host *host)
2780-{
2781- struct sdhci_throughput *mmc_thpt;
2782-
2783- mmc_thpt = &mmc_throughput[host->mmc->index];
2784-
2785- debugfs_remove(mmc_thpt->dentry[0]);
2786- debugfs_remove(mmc_thpt->dentry[1]);
2787- debugfs_remove(mmc_thpt->dentry[2]);
2788-}
2789-
2790-
2791-static int sdhci_debugfs_throughput_init(
2792- struct sdhci_host *host,
2793- struct mmc_host *mmc
2794-)
2795+#else
2796+static int sdhci_is_adma2_64bit(struct sdhci_host *host)
2797 {
2798- struct sdhci_throughput *mmc_thpt;
2799-
2800- mmc_throughput = krealloc(mmc_throughput, ((host->mmc->index + 1) \
2801- * sizeof(sdhci_throughput_t)), GFP_KERNEL);
2802-
2803- if (!mmc_throughput) {
2804- printk(KERN_ERR "Error allocating memory sdhci-throughput\n");
2805- return -ENOMEM;
2806- }
2807-
2808- mmc_thpt = &mmc_throughput[host->mmc->index];
2809- memset(mmc_thpt, 0, sizeof(sdhci_throughput_t));
2810- host->thrpt_dbgfs_enable = 0;
2811-
2812- if (sdhci_throughput_dentry == NULL) {
2813- sdhci_throughput_dentry =
2814- debugfs_create_dir("sdhci-throughput", NULL);
2815- pr_info("sdhci-throughput: creating root dir Passed\n");
2816- }
2817-
2818- if (likely(sdhci_throughput_dentry != NULL)) {
2819- /* create the host controller directory */
2820- mmc_thpt->dentry[0] = \
2821- debugfs_create_dir(mmc_hostname(mmc), \
2822- sdhci_throughput_dentry);
2823- if (unlikely(mmc_thpt->dentry[0] == NULL))
2824- goto err;
2825-
2826- /* create enable entry */
2827- mmc_thpt->dentry[1] = \
2828- debugfs_create_u8("enable", 0664, \
2829- mmc_thpt->dentry[0], &(host->thrpt_dbgfs_enable));
2830- if (unlikely(mmc_thpt->dentry[1] == NULL))
2831- goto err;
2832-
2833- /* create throughput file */
2834- mmc_thpt->dentry[2] = \
2835- debugfs_create_file("throughput", 0644, \
2836- mmc_thpt->dentry[0], host, &sdhci_thrpt_fops);
2837-
2838- if (unlikely(mmc_thpt->dentry[2] == NULL))
2839- goto err;
2840- } else {
2841- printk(KERN_ERR "sdhci-throughput: creating root dir failed\n");
2842- }
2843 return 0;
2844-err:
2845- printk(KERN_ERR "Error in creating sdhci throughput debugfs inerface %s\n",
2846- mmc_hostname(mmc));
2847- sdhci_debugfs_throughput_remove(host);
2848- return -EINVAL;
2849 }
2850 #endif
2851
2852@@ -3235,7 +3549,6 @@ int sdhci_add_host(struct sdhci_host *host)
2853 u32 max_current_caps;
2854 unsigned int ocr_avail;
2855 int ret;
2856- unsigned int vendor_version = 0;
2857
2858 WARN_ON(host == NULL);
2859 if (host == NULL)
2860@@ -3251,10 +3564,6 @@ int sdhci_add_host(struct sdhci_host *host)
2861 sdhci_reset(host, SDHCI_RESET_ALL);
2862
2863 host->version = sdhci_readw(host, SDHCI_HOST_VERSION);
2864- vendor_version = (host->version & SDHCI_VENDOR_VER_MASK)
2865- >> SDHCI_VENDOR_VER_SHIFT;
2866-
2867- host->version = sdhci_readw(host, SDHCI_HOST_VERSION);
2868 host->version = (host->version & SDHCI_SPEC_VER_MASK)
2869 >> SDHCI_SPEC_VER_SHIFT;
2870 if (host->version > SDHCI_SPEC_300) {
2871@@ -3285,8 +3594,11 @@ int sdhci_add_host(struct sdhci_host *host)
2872 }
2873
2874 if ((host->version >= SDHCI_SPEC_200) &&
2875- (caps[0] & SDHCI_CAN_DO_ADMA2))
2876+ (caps[0] & SDHCI_CAN_DO_ADMA2)) {
2877 host->flags |= SDHCI_USE_ADMA;
2878+ if (sdhci_is_adma2_64bit(host))
2879+ host->flags |= SDHCI_USE_ADMA_64BIT;
2880+ }
2881
2882 if ((host->quirks & SDHCI_QUIRK_BROKEN_ADMA) &&
2883 (host->flags & SDHCI_USE_ADMA)) {
2884@@ -3309,21 +3621,70 @@ int sdhci_add_host(struct sdhci_host *host)
2885 if (host->flags & SDHCI_USE_ADMA) {
2886 /*
2887 * We need to allocate descriptors for all sg entries
2888- * (128) and potentially one alignment transfer for
2889+ * (128/max_segments) and potentially one alignment transfer for
2890 * each of those entries.
2891 */
2892- host->adma_desc = kmalloc((128 * 2 + 1) * 4, GFP_KERNEL);
2893- host->align_buffer = kmalloc(128 * 4, GFP_KERNEL);
2894+ if (host->ops->get_max_segments)
2895+ host->adma_max_desc = host->ops->get_max_segments();
2896+ else
2897+ host->adma_max_desc = 128;
2898+
2899+ if (host->flags & SDHCI_USE_ADMA_64BIT) {
2900+ host->adma_desc_line_sz = 12;
2901+ host->align_bytes = 8;
2902+ } else {
2903+ host->adma_desc_line_sz = 8;
2904+ host->align_bytes = 4;
2905+ }
2906+ host->adma_desc_sz = (host->adma_max_desc * 2 + 1) *
2907+ host->adma_desc_line_sz;
2908+ host->align_buf_sz = host->adma_max_desc * host->align_bytes;
2909+
2910+ pr_debug("%s: %s: dma_desc_size: %d\n",
2911+ mmc_hostname(host->mmc), __func__, host->adma_desc_sz);
2912+ host->adma_desc = dma_alloc_coherent(mmc_dev(host->mmc),
2913+ host->adma_desc_sz,
2914+ &host->adma_addr,
2915+ GFP_KERNEL);
2916+ host->align_buffer = dma_alloc_coherent(mmc_dev(host->mmc),
2917+ host->align_buf_sz,
2918+ &host->align_addr,
2919+ GFP_KERNEL);
2920 if (!host->adma_desc || !host->align_buffer) {
2921- kfree(host->adma_desc);
2922- kfree(host->align_buffer);
2923- pr_warning("%s: Unable to allocate ADMA "
2924+ dma_free_coherent(mmc_dev(host->mmc),
2925+ host->adma_desc_sz,
2926+ host->adma_desc,
2927+ host->adma_addr);
2928+ dma_free_coherent(mmc_dev(host->mmc),
2929+ host->align_buf_sz,
2930+ host->align_buffer,
2931+ host->align_addr);
2932+ pr_warn("%s: Unable to allocate ADMA "
2933 "buffers. Falling back to standard DMA.\n",
2934 mmc_hostname(mmc));
2935 host->flags &= ~SDHCI_USE_ADMA;
2936+ host->adma_desc = NULL;
2937+ host->align_buffer = NULL;
2938+ } else if ((host->adma_addr & (host->align_bytes - 1)) ||
2939+ (host->align_addr & (host->align_bytes - 1))) {
2940+ dma_free_coherent(mmc_dev(host->mmc),
2941+ host->adma_desc_sz,
2942+ host->adma_desc,
2943+ host->adma_addr);
2944+ dma_free_coherent(mmc_dev(host->mmc),
2945+ host->align_buf_sz,
2946+ host->align_buffer,
2947+ host->align_addr);
2948+ pr_warn("%s: Unable to allocate aligned ADMA buffers.\n",
2949+ mmc_hostname(mmc));
2950+ host->flags &= ~SDHCI_USE_ADMA;
2951+ host->adma_desc = NULL;
2952+ host->align_buffer = NULL;
2953 }
2954 }
2955
2956+ host->next_data.cookie = 1;
2957+
2958 /*
2959 * If we use DMA, then it's up to the caller to set the DMA
2960 * mask, but PIO does not need the hw shim so we set a new
2961@@ -3335,11 +3696,12 @@ int sdhci_add_host(struct sdhci_host *host)
2962 }
2963
2964 #ifdef CONFIG_MMC_BCM_SD
2965- if (host->ops->get_max_clock)
2966- host->max_clk = host->ops->get_max_clock(host);
2967- else
2968- host->max_clk = 0;
2969+ if (host->ops->get_max_clock)
2970+ host->max_clk = host->ops->get_max_clock(host);
2971+ else
2972+ host->max_clk = 0;
2973 #else
2974+
2975 if (host->version >= SDHCI_SPEC_300)
2976 host->max_clk = (caps[0] & SDHCI_CLOCK_V3_BASE_MASK)
2977 >> SDHCI_CLOCK_BASE_SHIFT;
2978@@ -3380,11 +3742,6 @@ int sdhci_add_host(struct sdhci_host *host)
2979 */
2980 mmc->ops = &sdhci_ops;
2981 mmc->f_max = host->max_clk;
2982-#if defined(CONFIG_MACH_BCM2850_FPGA) || defined(CONFIG_MACH_BCM_FPGA) || \
2983- defined(CONFIG_MACH_BCM_FPGA_E)
2984- /* frequency divisor does not work on FPGA image */
2985- mmc->f_min = host->max_clk;
2986-#else
2987 if (host->ops->get_min_clock)
2988 mmc->f_min = host->ops->get_min_clock(host);
2989 else if (host->version >= SDHCI_SPEC_300) {
2990@@ -3395,7 +3752,7 @@ int sdhci_add_host(struct sdhci_host *host)
2991 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_300;
2992 } else
2993 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
2994-#endif
2995+
2996 host->timeout_clk =
2997 (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
2998 if (host->timeout_clk == 0) {
2999@@ -3414,12 +3771,8 @@ int sdhci_add_host(struct sdhci_host *host)
3000 if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
3001 host->timeout_clk = mmc->f_max / 1000;
3002
3003- /* max_discard_to is set to zero to speed up the secure erase operation
3004- * during factory reset. Work sdhci_work_wait_for_busy was already added
3005- * to wait for the busy signalling of ERASE operation to finish.
3006- */
3007- mmc->max_discard_to = 0;
3008-
3009+ if (!(host->quirks2 & SDHCI_QUIRK2_USE_MAX_DISCARD_SIZE))
3010+ mmc->max_discard_to = (1 << 27) / host->timeout_clk;
3011
3012 mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23;
3013
3014@@ -3429,12 +3782,10 @@ int sdhci_add_host(struct sdhci_host *host)
3015 /* Auto-CMD23 stuff only works in ADMA or PIO. */
3016 if ((host->version >= SDHCI_SPEC_300) &&
3017 ((host->flags & SDHCI_USE_ADMA) ||
3018- !(host->flags & SDHCI_USE_SDMA)) &&
3019- (vendor_version != 0xA7)) {
3020+ !(host->flags & SDHCI_USE_SDMA))) {
3021 host->flags |= SDHCI_AUTO_CMD23;
3022 DBG("%s: Auto-CMD23 available\n", mmc_hostname(mmc));
3023 } else {
3024- host->flags &= ~SDHCI_AUTO_CMD23;
3025 DBG("%s: Auto-CMD23 unavailable\n", mmc_hostname(mmc));
3026 }
3027
3028@@ -3451,20 +3802,22 @@ int sdhci_add_host(struct sdhci_host *host)
3029 if (host->quirks2 & SDHCI_QUIRK2_HOST_NO_CMD23)
3030 mmc->caps &= ~MMC_CAP_CMD23;
3031
3032-/* FPGA not fast enough for high speed */
3033-#if !defined(CONFIG_MACH_BCM2850_FPGA) && !defined(CONFIG_MACH_BCM_FPGA)
3034 if (caps[0] & SDHCI_CAN_DO_HISPD)
3035 #ifdef CONFIG_MMC_BCM_SD
3036 mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
3037 #else
3038- mmc->caps |= MMC_CAP_SD_HIGHSPEED;
3039-#endif
3040+ mmc->caps |= MMC_CAP_SD_HIGHSPEED;
3041 #endif
3042
3043+ /*
3044+ * Enable polling on when card detection is broken and no card detect
3045+ * gpio is present.
3046+ */
3047 if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
3048- !(host->mmc->caps & MMC_CAP_NONREMOVABLE))
3049+ !(host->mmc->caps & MMC_CAP_NONREMOVABLE) &&
3050+ (mmc_gpio_get_cd(host->mmc) < 0) &&
3051+ !(host->mmc->caps2 & MMC_CAP2_NONHOTPLUG))
3052 mmc->caps |= MMC_CAP_NEEDS_POLL;
3053-
3054 /* If vqmmc regulator and no 1.8V signalling, then there's no UHS */
3055 host->vqmmc = regulator_get(mmc_dev(mmc), "vqmmc");
3056 if (IS_ERR_OR_NULL(host->vqmmc)) {
3057@@ -3491,8 +3844,6 @@ int sdhci_add_host(struct sdhci_host *host)
3058 caps[1] &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
3059 SDHCI_SUPPORT_DDR50);
3060
3061-#if !defined(CONFIG_ARCH_ISLAND) && !defined(CONFIG_ARCH_CAPRI)\
3062- && !defined(CONFIG_MACH_BCM_FPGA)
3063 /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */
3064 if (caps[1] & (SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
3065 SDHCI_SUPPORT_DDR50))
3066@@ -3514,7 +3865,10 @@ int sdhci_add_host(struct sdhci_host *host)
3067 /* Does the host need tuning for HS200? */
3068 if (mmc->caps2 & MMC_CAP2_HS200)
3069 host->flags |= SDHCI_HS200_NEEDS_TUNING;
3070-#endif
3071+
3072+ /* Does the host need tuning for HS400? */
3073+ if (mmc->caps2 & MMC_CAP2_HS400)
3074+ host->flags |= SDHCI_HS400_NEEDS_TUNING;
3075
3076 /* Driver Type(s) (A, C, D) supported by the host */
3077 if (caps[1] & SDHCI_DRIVER_TYPE_A)
3078@@ -3637,24 +3991,26 @@ int sdhci_add_host(struct sdhci_host *host)
3079 return -ENODEV;
3080 }
3081
3082- spin_lock_init(&host->lock);
3083-
3084 /*
3085 * Maximum number of segments. Depends on if the hardware
3086 * can do scatter/gather or not.
3087 */
3088 if (host->flags & SDHCI_USE_ADMA)
3089- mmc->max_segs = 128;
3090+ mmc->max_segs = host->adma_max_desc;
3091 else if (host->flags & SDHCI_USE_SDMA)
3092 mmc->max_segs = 1;
3093- else /* PIO */
3094+ else/* PIO */
3095 mmc->max_segs = 128;
3096
3097 /*
3098 * Maximum number of sectors in one transfer. Limited by DMA boundary
3099- * size (512KiB).
3100+ * size (512KiB), unless specified by platform specific driver. Each
3101+ * descriptor can transfer a maximum of 64KB.
3102 */
3103- mmc->max_req_size = 524288;
3104+ if (host->flags & SDHCI_USE_ADMA)
3105+ mmc->max_req_size = (host->adma_max_desc * 65536);
3106+ else
3107+ mmc->max_req_size = 524288;
3108
3109 /*
3110 * Maximum segment size. Could be one segment with the maximum number
3111@@ -3680,7 +4036,7 @@ int sdhci_add_host(struct sdhci_host *host)
3112 mmc->max_blk_size = (caps[0] & SDHCI_MAX_BLOCK_MASK) >>
3113 SDHCI_MAX_BLOCK_SHIFT;
3114 #ifdef CONFIG_MMC_BCM_SD
3115- if (mmc->max_blk_size > 3) {
3116+ if (mmc->max_blk_size > 3) {
3117 #else
3118 if (mmc->max_blk_size >= 3) {
3119 #endif
3120@@ -3690,9 +4046,6 @@ int sdhci_add_host(struct sdhci_host *host)
3121 }
3122 }
3123
3124- if (host->quirks2 & SDHCI_QUIRK2_HOST_DISABLE_DDR)
3125- mmc->caps &= ~MMC_CAP_UHS_DDR50;
3126-
3127 mmc->max_blk_size = 512 << mmc->max_blk_size;
3128
3129 /*
3130@@ -3709,7 +4062,6 @@ int sdhci_add_host(struct sdhci_host *host)
3131 sdhci_tasklet_finish, (unsigned long)host);
3132
3133 setup_timer(&host->timer, sdhci_timeout_timer, (unsigned long)host);
3134- INIT_WORK(&host->wait_for_busy_work, sdhci_work_wait_for_busy);
3135
3136 if (host->version >= SDHCI_SPEC_300) {
3137 init_waitqueue_head(&host->buf_ready_int);
3138@@ -3728,6 +4080,8 @@ int sdhci_add_host(struct sdhci_host *host)
3139 goto untasklet;
3140 }
3141
3142+ host->irq_enabled = true;
3143+
3144 sdhci_init(host, 0);
3145
3146 #ifdef CONFIG_MMC_DEBUG
3147@@ -3752,18 +4106,38 @@ int sdhci_add_host(struct sdhci_host *host)
3148
3149 mmiowb();
3150
3151- mmc_add_host(mmc);
3152+ if (host->cpu_dma_latency_us) {
3153+ host->pm_qos_timeout_us = 10000; /* default value */
3154+ sdhci_set_pmqos_req_type(host, true);
3155+ pm_qos_add_request(&host->pm_qos_req_dma,
3156+ PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE);
3157+
3158+ host->pm_qos_tout.show = show_sdhci_pm_qos_tout;
3159+ host->pm_qos_tout.store = store_sdhci_pm_qos_tout;
3160+ sysfs_attr_init(&host->pm_qos_tout.attr);
3161+ host->pm_qos_tout.attr.name = "pm_qos_unvote_delay";
3162+ host->pm_qos_tout.attr.mode = S_IRUGO | S_IWUSR;
3163+ ret = device_create_file(mmc_dev(mmc), &host->pm_qos_tout);
3164+ if (ret)
3165+ pr_err("%s: cannot create pm_qos_unvote_delay %d\n",
3166+ mmc_hostname(mmc), ret);
3167+ }
3168+
3169+ if (caps[0] & SDHCI_ASYNC_INTR)
3170+ host->async_int_supp = true;
3171
3172+ if (host->quirks2 & SDHCI_QUIRK2_IGN_DATA_END_BIT_ERROR)
3173+ sdhci_clear_set_irqs(host, SDHCI_INT_DATA_END_BIT, 0);
3174 pr_info("%s: SDHCI controller on %s [%s] using %s\n",
3175 mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
3176- (host->flags & SDHCI_USE_ADMA) ? "ADMA" :
3177- (host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
3178+ (host->flags & SDHCI_USE_ADMA) ?
3179+ ((host->flags & SDHCI_USE_ADMA_64BIT) ?
3180+ "64-bit ADMA" : "32-bit ADMA") :
3181+ ((host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO"));
3182
3183 sdhci_enable_card_detection(host);
3184
3185-#ifdef CONFIG_SDHCI_THROUGHPUT
3186- sdhci_debugfs_throughput_init(host, mmc);
3187-#endif
3188+ mmc_add_host(mmc);
3189 return 0;
3190
3191 #ifdef SDHCI_USE_LEDS_CLASS
3192@@ -3803,11 +4177,8 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
3193
3194 sdhci_disable_card_detection(host);
3195
3196-#ifdef CONFIG_SDHCI_THROUGHPUT
3197- if (mmc_throughput)
3198- sdhci_debugfs_throughput_remove(host);
3199-#endif
3200-
3201+ if (host->cpu_dma_latency_us)
3202+ pm_qos_remove_request(&host->pm_qos_req_dma);
3203 mmc_remove_host(host->mmc);
3204
3205 #ifdef SDHCI_USE_LEDS_CLASS
3206@@ -3820,8 +4191,6 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
3207 sdhci_mask_irqs(host, SDHCI_INT_ALL_MASK);
3208 free_irq(host->irq, host);
3209
3210- flush_work(&host->wait_for_busy_work);
3211-
3212 del_timer_sync(&host->timer);
3213
3214 tasklet_kill(&host->card_tasklet);
3215@@ -3837,8 +4206,12 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
3216 regulator_put(host->vqmmc);
3217 }
3218
3219- kfree(host->adma_desc);
3220- kfree(host->align_buffer);
3221+ if (host->adma_desc)
3222+ dma_free_coherent(mmc_dev(host->mmc), host->adma_desc_sz,
3223+ host->adma_desc, host->adma_addr);
3224+ if (host->align_buffer)
3225+ dma_free_coherent(mmc_dev(host->mmc), host->align_buf_sz,
3226+ host->align_buffer, host->align_addr);
3227
3228 host->adma_desc = NULL;
3229 host->align_buffer = NULL;
3230@@ -3863,26 +4236,13 @@ static int __init sdhci_drv_init(void)
3231 {
3232 pr_info(DRIVER_NAME
3233 ": Secure Digital Host Controller Interface driver\n");
3234- pr_info(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
3235-#ifdef CONFIG_BCM_SDIOWL // BROADCOM MODIFICATION
3236- pr_info(KERN_INFO DRIVER_NAME ": modified by Broadcom for SDIO Wireless purposes\n");
3237-#endif
3238-
3239-#ifdef CONFIG_SDHCI_THROUGHPUT
3240- sdhci_throughput_dentry = debugfs_create_dir("sdhci-throughput", NULL);
3241- if (!sdhci_throughput_dentry)
3242- pr_info(KERN_ERR "sdhci-throughput: creating root dir failed\n");
3243-#endif
3244+ pr_info(DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
3245
3246 return 0;
3247 }
3248
3249 static void __exit sdhci_drv_exit(void)
3250 {
3251-#ifdef CONFIG_SDHCI_THROUGHPUT
3252- kfree(mmc_throughput);
3253- debugfs_remove_recursive(sdhci_throughput_dentry);
3254-#endif
3255 }
3256
3257 module_init(sdhci_drv_init);
3258diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
3259index b976536..e1bda8e 100644
3260--- a/drivers/mmc/host/sdhci.h
3261+++ b/drivers/mmc/host/sdhci.h
3262@@ -71,7 +71,6 @@
3263 #define SDHCI_CARD_PRESENT 0x00010000
3264 #define SDHCI_WRITE_PROTECT 0x00080000
3265 #define SDHCI_DATA_LVL_MASK 0x00F00000
3266-#define SDHCI_DATA_LVL_DAT0_MASK 0x00100000
3267 #define SDHCI_DATA_LVL_SHIFT 20
3268
3269 #define SDHCI_HOST_CONTROL 0x28
3270@@ -137,14 +136,16 @@
3271 #define SDHCI_INT_DATA_CRC 0x00200000
3272 #define SDHCI_INT_DATA_END_BIT 0x00400000
3273 #define SDHCI_INT_BUS_POWER 0x00800000
3274-#define SDHCI_INT_ACMD12ERR 0x01000000
3275+#define SDHCI_INT_AUTO_CMD_ERR 0x01000000
3276 #define SDHCI_INT_ADMA_ERROR 0x02000000
3277
3278 #define SDHCI_INT_NORMAL_MASK 0x00007FFF
3279 #define SDHCI_INT_ERROR_MASK 0xFFFF8000
3280
3281 #define SDHCI_INT_CMD_MASK (SDHCI_INT_RESPONSE | SDHCI_INT_TIMEOUT | \
3282- SDHCI_INT_CRC | SDHCI_INT_END_BIT | SDHCI_INT_INDEX)
3283+ SDHCI_INT_CRC | SDHCI_INT_END_BIT | SDHCI_INT_INDEX | \
3284+ SDHCI_INT_AUTO_CMD_ERR)
3285+
3286 #define SDHCI_INT_DATA_MASK (SDHCI_INT_DATA_END | SDHCI_INT_DMA_END | \
3287 SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL | \
3288 SDHCI_INT_DATA_TIMEOUT | SDHCI_INT_DATA_CRC | \
3289@@ -152,7 +153,13 @@
3290 SDHCI_INT_BLK_GAP)
3291 #define SDHCI_INT_ALL_MASK ((unsigned int)-1)
3292
3293-#define SDHCI_ACMD12_ERR 0x3C
3294+#define SDHCI_AUTO_CMD_ERR 0x3C
3295+#define SDHCI_AUTO_CMD12_NOT_EXEC 0x0001
3296+#define SDHCI_AUTO_CMD_TIMEOUT_ERR 0x0002
3297+#define SDHCI_AUTO_CMD_CRC_ERR 0x0004
3298+#define SDHCI_AUTO_CMD_ENDBIT_ERR 0x0008
3299+#define SDHCI_AUTO_CMD_INDEX_ERR 0x0010
3300+#define SDHCI_AUTO_CMD12_NOT_ISSUED 0x0080
3301
3302 #define SDHCI_HOST_CONTROL2 0x3E
3303 #define SDHCI_CTRL_UHS_MASK 0x0007
3304@@ -170,6 +177,7 @@
3305 #define SDHCI_CTRL_DRV_TYPE_D 0x0030
3306 #define SDHCI_CTRL_EXEC_TUNING 0x0040
3307 #define SDHCI_CTRL_TUNED_CLK 0x0080
3308+#define SDHCI_CTRL_ASYNC_INT_ENABLE 0x4000
3309 #define SDHCI_CTRL_PRESET_VAL_ENABLE 0x8000
3310
3311 #define SDHCI_CAPABILITIES 0x40
3312@@ -190,6 +198,7 @@
3313 #define SDHCI_CAN_VDD_300 0x02000000
3314 #define SDHCI_CAN_VDD_180 0x04000000
3315 #define SDHCI_CAN_64BIT 0x10000000
3316+#define SDHCI_ASYNC_INTR 0x20000000
3317
3318 #define SDHCI_SUPPORT_SDR50 0x00000001
3319 #define SDHCI_SUPPORT_SDR104 0x00000002
3320@@ -226,7 +235,9 @@
3321
3322 /* 55-57 reserved */
3323
3324-#define SDHCI_ADMA_ADDRESS 0x58
3325+#define SDHCI_HI_SHIFT 32
3326+#define SDHCI_ADMA_ADDRESS_LOW 0x58 /* addr[0:31] */
3327+#define SDHCI_ADMA_ADDRESS_HIGH 0x5C /* addr[32:63] */
3328
3329 /* 60-FB reserved */
3330
3331@@ -279,12 +290,12 @@ struct sdhci_ops {
3332 void (*set_clock)(struct sdhci_host *host, unsigned int clock);
3333
3334 #ifdef CONFIG_MMC_SDHCI_PLTFM_KONA
3335- int (*set_signalling)(struct sdhci_host *host, int sig_vol);
3336- int (*clk_enable)(struct sdhci_host *host, int enable);
3337- int (*rpm_enabled)(struct sdhci_host *host);
3338- int (*set_regulator)(struct sdhci_host *host,
3339- int power_state);
3340-#endif
3341+ int (*set_signalling)(struct sdhci_host *host, int sig_vol);
3342+ int (*clk_enable)(struct sdhci_host *host, int enable);
3343+ int (*rpm_enabled)(struct sdhci_host *host);
3344+ int (*set_regulator)(struct sdhci_host *host,
3345+ int power_state);
3346+#endif
3347
3348 int (*enable_dma)(struct sdhci_host *host);
3349 unsigned int (*get_max_clock)(struct sdhci_host *host);
3350@@ -303,7 +314,21 @@ struct sdhci_ops {
3351 void (*platform_resume)(struct sdhci_host *host);
3352 void (*adma_workaround)(struct sdhci_host *host, u32 intmask);
3353 void (*platform_init)(struct sdhci_host *host);
3354- void (*sdhci_debug)(struct sdhci_host *host);
3355+ void (*check_power_status)(struct sdhci_host *host, u32 req_type);
3356+#define REQ_BUS_OFF (1 << 0)
3357+#define REQ_BUS_ON (1 << 1)
3358+#define REQ_IO_LOW (1 << 2)
3359+#define REQ_IO_HIGH (1 << 3)
3360+ int (*execute_tuning)(struct sdhci_host *host, u32 opcode);
3361+ void (*toggle_cdr)(struct sdhci_host *host, bool enable);
3362+ unsigned int (*get_max_segments)(void);
3363+ void (*platform_bus_voting)(struct sdhci_host *host, u32 enable);
3364+ void (*disable_data_xfer)(struct sdhci_host *host);
3365+ void (*dump_vendor_regs)(struct sdhci_host *host);
3366+ int (*config_auto_tuning_cmd)(struct sdhci_host *host,
3367+ bool enable,
3368+ u32 type);
3369+ int (*enable_controller_clock)(struct sdhci_host *host);
3370 };
3371
3372 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
3373@@ -414,4 +439,5 @@ extern int sdhci_runtime_suspend_host(struct sdhci_host *host);
3374 extern int sdhci_runtime_resume_host(struct sdhci_host *host);
3375 #endif
3376
3377+void sdhci_cfg_irq(struct sdhci_host *host, bool enable, bool sync);
3378 #endif /* __SDHCI_HW_H */
3379diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
3380index f17d2f8..2b1d842 100644
3381--- a/drivers/usb/gadget/Kconfig
3382+++ b/drivers/usb/gadget/Kconfig
3383@@ -441,6 +441,7 @@ config USB_GOKU
3384
3385 config USB_EG20T
3386 tristate "Intel EG20T PCH/LAPIS Semiconductor IOH(ML7213/ML7831) UDC"
3387+ depends on PCI
3388 help
3389 This is a USB device driver for EG20T PCH.
3390 EG20T PCH is the platform controller hub that is used in Intel's
3391@@ -476,6 +477,43 @@ config USB_CI13XXX_MSM
3392 dynamically linked module called "ci13xxx_msm" and force all
3393 gadget drivers to also be dynamically linked.
3394
3395+config USB_CI13XXX_MSM_HSIC
3396+ tristate "MIPS HSIC CI13xxx for MSM"
3397+ depends on ARCH_MSM
3398+ select USB_GADGET_DUALSPEED
3399+ help
3400+ MSM SoC has chipidea USB controller. This driver uses
3401+ ci13xxx_udc core. Support USB-HSIC core.
3402+
3403+ Say "y" to link the driver statically, or "m" to build a
3404+ dynamically linked module called "ci13xxx_msm_hsic" and force all
3405+ gadget drivers to also be dynamically linked.
3406+
3407+config USB_DWC3_MSM
3408+ tristate "DesignWare USB3.0 (DRD) Controller for MSM"
3409+ depends on ARCH_MSM
3410+ select USB_DWC3
3411+ select USB_GADGET_DUALSPEED
3412+ select USB_GADGET_SELECTED
3413+ help
3414+ The DesignWare USB3.0 controller is a SuperSpeed USB3.0 Controller
3415+ integrated into the Qualcomm MSM chipset series, supporting host,
3416+ device and otg modes of operation. For more information please
3417+ refer to http://www.qualcomm.com/chipsets.
3418+
3419+config USB_DWC3_OMAP
3420+ tristate "DesignWare USB3.0 (DRD) Controller for OMAP"
3421+ depends on ARCH_OMAP
3422+ select USB_DWC3
3423+ select USB_GADGET_DUALSPEED
3424+ select USB_GADGET_SUPERSPEED
3425+ select USB_GADGET_SELECTED
3426+ help
3427+ DesignWare USB3.0 controller is a SuperSpeed USB3.0 Controller
3428+ which can be configured for peripheral-only, host-only, hub-only
3429+ and Dual-Role operation. This Controller was first integrated into
3430+ the OMAP5 series of processors. More information about the OMAP5
3431+ version of this controller, refer to http://www.ti.com/omap5.
3432
3433 config USB_GADGET_DWC_OTG
3434 tristate "Synopsys DWC_OTG 2.91a"
3435@@ -955,14 +993,6 @@ config USB_ETH_SKB_ALLOC_OPTIMIZATION
3436
3437 If unsure, say "y".
3438
3439-config USB_PCD_SETTINGS
3440- bool "USB_PCD_SETTINGS support"
3441- depends on USB_G_ANDROID
3442- help
3443- If you say "y" here, the dynamic switching of usb gadget classes is supported
3444- This does the GADGET function switch cleanly
3445- If unsure, say "y".
3446-
3447 if TTY
3448 config USB_CDC_COMPOSITE
3449 tristate "CDC Composite Device (Ethernet and ACM)"
3450@@ -1116,4 +1146,79 @@ config USB_G_WEBCAM
3451
3452 endchoice
3453
3454+config USB_CSW_HACK
3455+ boolean "USB Mass storage csw hack Feature"
3456+ default y
3457+ help
3458+ This csw hack feature is for increasing the performance of the mass
3459+ storage
3460+
3461+config USB_MSC_PROFILING
3462+ bool "USB MSC performance profiling"
3463+ help
3464+ If you say Y here, support will be added for collecting
3465+ Mass-storage performance numbers at the VFS level.
3466+
3467+config MODEM_SUPPORT
3468+ boolean "modem support in generic serial function driver"
3469+ depends on USB_G_ANDROID
3470+ default y
3471+ help
3472+ This feature enables the modem functionality in the
3473+ generic serial.
3474+ adds interrupt endpoint support to send modem notifications
3475+ to host.
3476+ adds CDC descriptors to enumerate the generic serial as MODEM.
3477+ adds CDC class requests to configure MODEM line settings.
3478+ Say "y" to enable MODEM support in the generic serial driver.
3479+
3480+config RMNET_SMD_CTL_CHANNEL
3481+ string "RMNET control SMD channel name"
3482+ depends on USB_G_ANDROID && MSM_SMD
3483+ default ""
3484+ help
3485+ Control SMD channel for transferring QMI messages
3486+
3487+config RMNET_SMD_DATA_CHANNEL
3488+ string "RMNET Data SMD channel name"
3489+ depends on USB_G_ANDROID && MSM_SMD
3490+ default ""
3491+ help
3492+ Data SMD channel for transferring network data
3493+
3494+config RMNET_SDIO_CTL_CHANNEL
3495+ int "RMNET control SDIO channel id"
3496+ default 8
3497+ depends on MSM_SDIO_CMUX && MSM_SDIO_DMUX
3498+ help
3499+ Control SDIO channel for transferring RMNET QMI messages
3500+
3501+config RMNET_SDIO_DATA_CHANNEL
3502+ int "RMNET Data SDIO channel id"
3503+ default 8
3504+ depends on MSM_SDIO_CMUX && MSM_SDIO_DMUX
3505+ help
3506+ Data SDIO channel for transferring network data
3507+
3508+config RMNET_SMD_SDIO_CTL_CHANNEL
3509+ int "RMNET(sdio_smd) Control SDIO channel id"
3510+ depends on MSM_SDIO_CMUX && MSM_SDIO_DMUX
3511+ default 8
3512+ help
3513+ Control SDIO channel for transferring QMI messages
3514+
3515+config RMNET_SMD_SDIO_DATA_CHANNEL
3516+ int "RMNET(sdio_smd) Data SDIO channel id"
3517+ default 8
3518+ depends on MSM_SDIO_CMUX && MSM_SDIO_DMUX
3519+ help
3520+ Data SDIO channel for transferring network data
3521+
3522+config RMNET_SDIO_SMD_DATA_CHANNEL
3523+ string "RMNET(sdio_smd) Data SMD channel name"
3524+ depends on MSM_SDIO_CMUX && MSM_SDIO_DMUX
3525+ default "DATA40"
3526+ help
3527+ Data SMD channel for transferring network data
3528+
3529 endif # USB_GADGET
3530diff --git a/drivers/usb/gadget/android.c b/drivers/usb/gadget/android.c
3531index 70d3150..b7ce3cc 100644
3532--- a/drivers/usb/gadget/android.c
3533+++ b/drivers/usb/gadget/android.c
3534@@ -2,6 +2,7 @@
3535 * Gadget Driver for Android
3536 *
3537 * Copyright (C) 2008 Google, Inc.
3538+ *.Copyright (c) 2014, The Linux Foundation. All rights reserved.
3539 * Author: Mike Lockwood <lockwood@android.com>
3540 * Benoit Goby <benoit@android.com>
3541 *
3542@@ -23,29 +24,58 @@
3543 #include <linux/kernel.h>
3544 #include <linux/utsname.h>
3545 #include <linux/platform_device.h>
3546+#include <linux/pm_qos.h>
3547+#include <linux/of.h>
3548
3549 #include <linux/usb/ch9.h>
3550 #include <linux/usb/composite.h>
3551 #include <linux/usb/gadget.h>
3552+#include <linux/usb/android.h>
3553+
3554+#include <linux/qcom/diag_dload.h>
3555
3556 #include "gadget_chips.h"
3557
3558-#include "f_hid.c"
3559 #include "f_fs.c"
3560-#ifdef CONFIG_SOUND
3561+#ifdef CONFIG_SND_PCM
3562 #include "f_audio_source.c"
3563 #endif
3564 #include "f_mass_storage.c"
3565+#define USB_ETH_RNDIS y
3566+#include "f_diag.c"
3567+#include "f_qdss.c"
3568+#include "f_rmnet_smd.c"
3569+#include "f_rmnet.c"
3570+#include "f_gps.c"
3571+#include "u_smd.c"
3572+#include "u_bam.c"
3573+#include "u_rmnet_ctrl_smd.c"
3574+#include "u_ctrl_qti.c"
3575+#include "u_ctrl_hsic.c"
3576+#include "u_data_hsic.c"
3577+#include "u_ctrl_hsuart.c"
3578+#include "u_data_hsuart.c"
3579+#include "f_ccid.c"
3580 #include "f_mtp.c"
3581 #include "f_accessory.c"
3582-#define USB_ETH_RNDIS y
3583 #include "f_rndis.c"
3584 #include "rndis.c"
3585-#include "f_ncm.c"
3586+#include "f_qc_ecm.c"
3587+#include "f_mbim.c"
3588+#include "f_qc_rndis.c"
3589+#include "u_data_ipa.c"
3590+#include "u_bam_data.c"
3591+#include "f_ecm.c"
3592 #include "u_ether.c"
3593-#ifdef CONFIG_USB_GADGET_GG
3594-#include "f_gg.c"
3595+#include "u_qc_ether.c"
3596+#ifdef CONFIG_TARGET_CORE
3597 #endif
3598+#ifdef CONFIG_SND_PCM
3599+#include "u_uac1.c"
3600+#include "f_uac1.c"
3601+#endif
3602+#include "f_ncm.c"
3603+#include "f_charger.c"
3604
3605 MODULE_AUTHOR("Mike Lockwood");
3606 MODULE_DESCRIPTION("Android Composite USB Driver");
3607@@ -58,6 +88,8 @@ static const char longname[] = "Gadget Android";
3608 #define VENDOR_ID 0x18D1
3609 #define PRODUCT_ID 0x0001
3610
3611+#define ANDROID_DEVICE_NODE_NAME_LENGTH 11
3612+
3613 struct android_usb_function {
3614 char *name;
3615 void *config;
3616@@ -66,8 +98,7 @@ struct android_usb_function {
3617 char *dev_name;
3618 struct device_attribute **attributes;
3619
3620- /* for android_dev.enabled_functions */
3621- struct list_head enabled_list;
3622+ struct android_dev *android_dev;
3623
3624 /* Optional: initialization during gadget bind */
3625 int (*init)(struct android_usb_function *, struct usb_composite_dev *);
3626@@ -91,26 +122,114 @@ struct android_usb_function {
3627 const struct usb_ctrlrequest *);
3628 };
3629
3630+struct android_usb_function_holder {
3631+
3632+ struct android_usb_function *f;
3633+
3634+ /* for android_conf.enabled_functions */
3635+ struct list_head enabled_list;
3636+};
3637+
3638+/**
3639+* struct android_dev - represents android USB gadget device
3640+* @name: device name.
3641+* @functions: an array of all the supported USB function
3642+* drivers that this gadget support but not necessarily
3643+* added to one of the gadget configurations.
3644+* @cdev: The internal composite device. Android gadget device
3645+* is a composite device, such that it can support configurations
3646+* with more than one function driver.
3647+* @dev: The kernel device that represents this android device.
3648+* @enabled: True if the android gadget is enabled, means all
3649+* the configurations were set and all function drivers were
3650+* bind and ready for USB enumeration.
3651+* @disable_depth: Number of times the device was disabled, after
3652+* symmetrical number of enables the device willl be enabled.
3653+* Used for controlling ADB userspace disable/enable requests.
3654+* @mutex: Internal mutex for protecting device member fields.
3655+* @pdata: Platform data fetched from the kernel device platfrom data.
3656+* @connected: True if got connect notification from the gadget UDC.
3657+* False if got disconnect notification from the gadget UDC.
3658+* @sw_connected: Equal to 'connected' only after the connect
3659+* notification was handled by the android gadget work function.
3660+* @suspended: True if got suspend notification from the gadget UDC.
3661+* False if got resume notification from the gadget UDC.
3662+* @sw_suspended: Equal to 'suspended' only after the susped
3663+* notification was handled by the android gadget work function.
3664+* @pm_qos: An attribute string that can be set by user space in order to
3665+* determine pm_qos policy. Set to 'high' for always demand pm_qos
3666+* when USB bus is connected and resumed. Set to 'low' for disable
3667+* any setting of pm_qos by this driver. Default = 'high'.
3668+* @work: workqueue used for handling notifications from the gadget UDC.
3669+* @configs: List of configurations currently configured into the device.
3670+* The android gadget supports more than one configuration. The host
3671+* may choose one configuration from the suggested.
3672+* @configs_num: Number of configurations currently configured and existing
3673+* in the configs list.
3674+* @list_item: This driver supports more than one android gadget device (for
3675+* example in order to support multiple USB cores), therefore this is
3676+* a item in a linked list of android devices.
3677+*/
3678 struct android_dev {
3679+ const char *name;
3680 struct android_usb_function **functions;
3681- struct list_head enabled_functions;
3682 struct usb_composite_dev *cdev;
3683 struct device *dev;
3684
3685+ void (*setup_complete)(struct usb_ep *ep,
3686+ struct usb_request *req);
3687+
3688 bool enabled;
3689 int disable_depth;
3690 struct mutex mutex;
3691+ struct android_usb_platform_data *pdata;
3692+
3693 bool connected;
3694 bool sw_connected;
3695+ bool suspended;
3696+ bool sw_suspended;
3697+ char pm_qos[5];
3698+ struct pm_qos_request pm_qos_req_dma;
3699+ unsigned up_pm_qos_sample_sec;
3700+ unsigned up_pm_qos_threshold;
3701+ unsigned down_pm_qos_sample_sec;
3702+ unsigned down_pm_qos_threshold;
3703+ unsigned idle_pc_rpm_no_int_secs;
3704+ struct delayed_work pm_qos_work;
3705+ enum android_pm_qos_state curr_pm_qos_state;
3706 struct work_struct work;
3707 char ffs_aliases[256];
3708+
3709+ /* A list of struct android_configuration */
3710+ struct list_head configs;
3711+ int configs_num;
3712+
3713+ /* A list node inside the android_dev_list */
3714+ struct list_head list_item;
3715+};
3716+
3717+struct android_configuration {
3718+ struct usb_configuration usb_config;
3719+
3720+ /* A list of the functions supported by this config */
3721+ struct list_head enabled_functions;
3722+
3723+ /* A list node inside the struct android_dev.configs list */
3724+ struct list_head list_item;
3725 };
3726
3727+struct dload_struct __iomem *diag_dload;
3728 static struct class *android_class;
3729-static struct android_dev *_android_dev;
3730+static struct list_head android_dev_list;
3731+static int android_dev_count;
3732 static int android_bind_config(struct usb_configuration *c);
3733 static void android_unbind_config(struct usb_configuration *c);
3734-static void android_disconnect(struct usb_composite_dev *cdev);
3735+static struct android_dev *cdev_to_android_dev(struct usb_composite_dev *cdev);
3736+static struct android_configuration *alloc_android_config
3737+ (struct android_dev *dev);
3738+static void free_android_config(struct android_dev *dev,
3739+ struct android_configuration *conf);
3740+static int usb_diag_update_pid_and_serial_num(uint32_t pid, const char *snum);
3741
3742 /* string IDs are assigned dynamically */
3743 #define STRING_MANUFACTURER_IDX 0
3744@@ -153,43 +272,198 @@ static struct usb_device_descriptor device_desc = {
3745 static struct usb_otg_descriptor otg_descriptor = {
3746 .bLength = sizeof otg_descriptor,
3747 .bDescriptorType = USB_DT_OTG,
3748- .bmAttributes = 0,
3749- .bcdOTG = __constant_cpu_to_le16(0x0200),
3750+ .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
3751+ .bcdOTG = __constant_cpu_to_le16(0x0200),
3752 };
3753-/*
3754+
3755 static const struct usb_descriptor_header *otg_desc[] = {
3756 (struct usb_descriptor_header *) &otg_descriptor,
3757 NULL,
3758 };
3759-*/
3760-static struct usb_configuration android_config_driver = {
3761- .label = "android",
3762- .unbind = android_unbind_config,
3763- .bConfigurationValue = 1,
3764- .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
3765- .MaxPower = 500, /* 500ma */
3766+
3767+static const char *pm_qos_to_string(enum android_pm_qos_state state)
3768+{
3769+ switch (state) {
3770+ case NO_USB_VOTE: return "NO_USB_VOTE";
3771+ case WFI: return "WFI";
3772+ case IDLE_PC: return "IDLE_PC";
3773+ case IDLE_PC_RPM: return "IDLE_PC_RPM";
3774+ default: return "INVALID_STATE";
3775+ }
3776+}
3777+
3778+static void android_pm_qos_update_latency(struct android_dev *dev, u32 latency)
3779+{
3780+ static int last_vote = -1;
3781+
3782+ if (latency == last_vote || !latency)
3783+ return;
3784+
3785+ pr_debug("%s: latency updated to: %d\n", __func__, latency);
3786+
3787+ pm_qos_update_request(&dev->pm_qos_req_dma, latency);
3788+
3789+ last_vote = latency;
3790+}
3791+
3792+#define DOWN_PM_QOS_SAMPLE_SEC 5
3793+#define DOWN_PM_QOS_THRESHOLD 100
3794+#define UP_PM_QOS_SAMPLE_SEC 3
3795+#define UP_PM_QOS_THRESHOLD 70
3796+#define IDLE_PC_RPM_NO_INT_SECS 10
3797+
3798+static void android_pm_qos_work(struct work_struct *data)
3799+{
3800+ struct android_dev *dev = container_of(data, struct android_dev,
3801+ pm_qos_work.work);
3802+ struct usb_gadget *gadget = dev->cdev->gadget;
3803+ unsigned next_latency, curr_sample_int_count;
3804+ unsigned next_sample_delay_sec;
3805+ enum android_pm_qos_state next_state = dev->curr_pm_qos_state;
3806+ static unsigned no_int_sample_count;
3807+
3808+ curr_sample_int_count = gadget->xfer_isr_count;
3809+ gadget->xfer_isr_count = 0;
3810+
3811+ switch (dev->curr_pm_qos_state) {
3812+ case WFI:
3813+ if (curr_sample_int_count <= dev->down_pm_qos_threshold) {
3814+ next_state = IDLE_PC;
3815+ next_sample_delay_sec = dev->up_pm_qos_sample_sec;
3816+ no_int_sample_count = 0;
3817+ } else {
3818+ next_sample_delay_sec = dev->down_pm_qos_sample_sec;
3819+ }
3820+ break;
3821+ case IDLE_PC:
3822+ if (!curr_sample_int_count)
3823+ no_int_sample_count++;
3824+ else
3825+ no_int_sample_count = 0;
3826+
3827+ if (curr_sample_int_count >= dev->up_pm_qos_threshold) {
3828+ next_state = WFI;
3829+ next_sample_delay_sec = dev->down_pm_qos_sample_sec;
3830+ } else if (no_int_sample_count >=
3831+ dev->idle_pc_rpm_no_int_secs/dev->up_pm_qos_sample_sec) {
3832+ next_state = IDLE_PC_RPM;
3833+ next_sample_delay_sec = dev->up_pm_qos_sample_sec;
3834+ } else {
3835+ next_sample_delay_sec = dev->up_pm_qos_sample_sec;
3836+ }
3837+ break;
3838+ case IDLE_PC_RPM:
3839+ if (curr_sample_int_count) {
3840+ next_state = WFI;
3841+ next_sample_delay_sec = dev->down_pm_qos_sample_sec;
3842+ no_int_sample_count = 0;
3843+ } else {
3844+ next_sample_delay_sec = 2 * dev->up_pm_qos_sample_sec;
3845+ }
3846+ break;
3847+ default:
3848+ pr_debug("invalid pm_qos_state (%u)\n", dev->curr_pm_qos_state);
3849+ return;
3850+ }
3851+
3852+ if (next_state != dev->curr_pm_qos_state) {
3853+ dev->curr_pm_qos_state = next_state;
3854+ next_latency = dev->pdata->pm_qos_latency[next_state];
3855+ android_pm_qos_update_latency(dev, next_latency);
3856+ pr_debug("%s: pm_qos_state:%s, interrupts in last sample:%d\n",
3857+ __func__, pm_qos_to_string(next_state),
3858+ curr_sample_int_count);
3859+ }
3860+
3861+ queue_delayed_work(system_nrt_wq, &dev->pm_qos_work,
3862+ msecs_to_jiffies(1000*next_sample_delay_sec));
3863+}
3864+
3865+enum android_device_state {
3866+ USB_DISCONNECTED,
3867+ USB_CONNECTED,
3868+ USB_CONFIGURED,
3869+ USB_SUSPENDED,
3870+ USB_RESUMED
3871 };
3872
3873 static void android_work(struct work_struct *data)
3874 {
3875 struct android_dev *dev = container_of(data, struct android_dev, work);
3876 struct usb_composite_dev *cdev = dev->cdev;
3877+ struct android_usb_platform_data *pdata = dev->pdata;
3878 char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL };
3879 char *connected[2] = { "USB_STATE=CONNECTED", NULL };
3880 char *configured[2] = { "USB_STATE=CONFIGURED", NULL };
3881+ char *suspended[2] = { "USB_STATE=SUSPENDED", NULL };
3882+ char *resumed[2] = { "USB_STATE=RESUMED", NULL };
3883 char **uevent_envp = NULL;
3884+ static enum android_device_state last_uevent, next_state;
3885 unsigned long flags;
3886+ int pm_qos_vote = -1;
3887
3888 spin_lock_irqsave(&cdev->lock, flags);
3889- if (cdev->config)
3890+ if (dev->suspended != dev->sw_suspended && cdev->config) {
3891+ if (strncmp(dev->pm_qos, "low", 3))
3892+ pm_qos_vote = dev->suspended ? 0 : 1;
3893+ next_state = dev->suspended ? USB_SUSPENDED : USB_RESUMED;
3894+ uevent_envp = dev->suspended ? suspended : resumed;
3895+ } else if (cdev->config) {
3896 uevent_envp = configured;
3897- else if (dev->connected != dev->sw_connected)
3898+ next_state = USB_CONFIGURED;
3899+ } else if (dev->connected != dev->sw_connected) {
3900 uevent_envp = dev->connected ? connected : disconnected;
3901+ next_state = dev->connected ? USB_CONNECTED : USB_DISCONNECTED;
3902+ if (dev->connected && strncmp(dev->pm_qos, "low", 3))
3903+ pm_qos_vote = 1;
3904+ else if (!dev->connected || !strncmp(dev->pm_qos, "low", 3))
3905+ pm_qos_vote = 0;
3906+ }
3907 dev->sw_connected = dev->connected;
3908+ dev->sw_suspended = dev->suspended;
3909 spin_unlock_irqrestore(&cdev->lock, flags);
3910
3911+ if (pdata->pm_qos_latency[0] && pm_qos_vote == 1) {
3912+ cancel_delayed_work_sync(&dev->pm_qos_work);
3913+ android_pm_qos_update_latency(dev, pdata->pm_qos_latency[WFI]);
3914+ dev->curr_pm_qos_state = WFI;
3915+ queue_delayed_work(system_nrt_wq, &dev->pm_qos_work,
3916+ msecs_to_jiffies(1000*dev->down_pm_qos_sample_sec));
3917+ } else if (pdata->pm_qos_latency[0] && pm_qos_vote == 0) {
3918+ cancel_delayed_work_sync(&dev->pm_qos_work);
3919+ android_pm_qos_update_latency(dev, PM_QOS_DEFAULT_VALUE);
3920+ dev->curr_pm_qos_state = NO_USB_VOTE;
3921+ }
3922+
3923 if (uevent_envp) {
3924- kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, uevent_envp);
3925+ /*
3926+ * Some userspace modules, e.g. MTP, work correctly only if
3927+ * CONFIGURED uevent is preceded by DISCONNECT uevent.
3928+ * Check if we missed sending out a DISCONNECT uevent. This can
3929+ * happen if host PC resets and configures device really quick.
3930+ */
3931+ if (((uevent_envp == connected) &&
3932+ (last_uevent != USB_DISCONNECTED)) ||
3933+ ((uevent_envp == configured) &&
3934+ (last_uevent == USB_CONFIGURED))) {
3935+ pr_info("%s: sent missed DISCONNECT event\n", __func__);
3936+ kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE,
3937+ disconnected);
3938+ msleep(20);
3939+ }
3940+ /*
3941+ * Before sending out CONFIGURED uevent give function drivers
3942+ * a chance to wakeup userspace threads and notify disconnect
3943+ */
3944+ if (uevent_envp == configured)
3945+ msleep(50);
3946+
3947+ /* Do not notify on suspend / resume */
3948+ if (next_state != USB_SUSPENDED && next_state != USB_RESUMED) {
3949+ kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE,
3950+ uevent_envp);
3951+ last_uevent = next_state;
3952+ }
3953 pr_info("%s: sent uevent %s\n", __func__, uevent_envp[0]);
3954 } else {
3955 pr_info("%s: did not send uevent (%d %d %p)\n", __func__,
3956@@ -197,44 +471,45 @@ static void android_work(struct work_struct *data)
3957 }
3958 }
3959
3960-static void android_enable(struct android_dev *dev)
3961+static int android_enable(struct android_dev *dev)
3962 {
3963 struct usb_composite_dev *cdev = dev->cdev;
3964+ struct android_configuration *conf;
3965+ int err = 0;
3966
3967- BUG_ON(!mutex_is_locked(&dev->mutex));
3968- BUG_ON(!dev->disable_depth);
3969+ if (WARN_ON(!dev->disable_depth))
3970+ return err;
3971
3972 if (--dev->disable_depth == 0) {
3973-#ifdef CONFIG_USB_PCD_SETTINGS
3974- usb_pcd_enable(cdev->gadget);
3975-#endif
3976- usb_add_config(cdev, &android_config_driver,
3977- android_bind_config);
3978+
3979+ list_for_each_entry(conf, &dev->configs, list_item) {
3980+ err = usb_add_config(cdev, &conf->usb_config,
3981+ android_bind_config);
3982+ if (err < 0) {
3983+ pr_err("%s: usb_add_config failed : err: %d\n",
3984+ __func__, err);
3985+ dev->disable_depth++;
3986+ return err;
3987+ }
3988+ }
3989 usb_gadget_connect(cdev->gadget);
3990 }
3991+
3992+ return err;
3993 }
3994
3995 static void android_disable(struct android_dev *dev)
3996 {
3997 struct usb_composite_dev *cdev = dev->cdev;
3998-
3999- BUG_ON(!mutex_is_locked(&dev->mutex));
4000+ struct android_configuration *conf;
4001
4002 if (dev->disable_depth++ == 0) {
4003 usb_gadget_disconnect(cdev->gadget);
4004 /* Cancel pending control requests */
4005 usb_ep_dequeue(cdev->gadget->ep0, cdev->req);
4006- usb_remove_config(cdev, &android_config_driver);
4007- /*
4008- * Moving the disconnect uevent to after
4009- * cdev->config is made NULL. Else, if the
4010- * android_work is scheduled before cdev->config
4011- * is made NULL we may miss out the disconnect uevent.
4012- */
4013- android_disconnect(cdev);
4014-#ifdef CONFIG_USB_PCD_SETTINGS
4015- usb_pcd_disable(cdev->gadget);
4016-#endif
4017+
4018+ list_for_each_entry(conf, &dev->configs, list_item)
4019+ usb_remove_config(cdev, &conf->usb_config);
4020 }
4021 }
4022
4023@@ -245,6 +520,7 @@ struct functionfs_config {
4024 bool opened;
4025 bool enabled;
4026 struct ffs_data *data;
4027+ struct android_dev *dev;
4028 };
4029
4030 static int ffs_function_init(struct android_usb_function *f,
4031@@ -265,7 +541,7 @@ static void ffs_function_cleanup(struct android_usb_function *f)
4032
4033 static void ffs_function_enable(struct android_usb_function *f)
4034 {
4035- struct android_dev *dev = _android_dev;
4036+ struct android_dev *dev = f->android_dev;
4037 struct functionfs_config *config = f->config;
4038
4039 config->enabled = true;
4040@@ -277,7 +553,7 @@ static void ffs_function_enable(struct android_usb_function *f)
4041
4042 static void ffs_function_disable(struct android_usb_function *f)
4043 {
4044- struct android_dev *dev = _android_dev;
4045+ struct android_dev *dev = f->android_dev;
4046 struct functionfs_config *config = f->config;
4047
4048 config->enabled = false;
4049@@ -297,9 +573,12 @@ static int ffs_function_bind_config(struct android_usb_function *f,
4050 static ssize_t
4051 ffs_aliases_show(struct device *pdev, struct device_attribute *attr, char *buf)
4052 {
4053- struct android_dev *dev = _android_dev;
4054+ struct android_dev *dev;
4055 int ret;
4056
4057+ dev = list_first_entry(&android_dev_list, struct android_dev,
4058+ list_item);
4059+
4060 mutex_lock(&dev->mutex);
4061 ret = sprintf(buf, "%s\n", dev->ffs_aliases);
4062 mutex_unlock(&dev->mutex);
4063@@ -311,9 +590,11 @@ static ssize_t
4064 ffs_aliases_store(struct device *pdev, struct device_attribute *attr,
4065 const char *buf, size_t size)
4066 {
4067- struct android_dev *dev = _android_dev;
4068+ struct android_dev *dev;
4069 char buff[256];
4070
4071+ dev = list_first_entry(&android_dev_list, struct android_dev,
4072+ list_item);
4073 mutex_lock(&dev->mutex);
4074
4075 if (dev->enabled) {
4076@@ -348,48 +629,68 @@ static struct android_usb_function ffs_function = {
4077
4078 static int functionfs_ready_callback(struct ffs_data *ffs)
4079 {
4080- struct android_dev *dev = _android_dev;
4081+ struct android_dev *dev = ffs_function.android_dev;
4082 struct functionfs_config *config = ffs_function.config;
4083 int ret = 0;
4084
4085- mutex_lock(&dev->mutex);
4086-
4087- ret = functionfs_bind(ffs, dev->cdev);
4088- if (ret)
4089- goto err;
4090+ /* dev is null in case ADB is not in the composition */
4091+ if (dev) {
4092+ mutex_lock(&dev->mutex);
4093+ ret = functionfs_bind(ffs, dev->cdev);
4094+ if (ret) {
4095+ mutex_unlock(&dev->mutex);
4096+ return ret;
4097+ }
4098+ } else {
4099+ /* android ffs_func requires daemon to start only after enable*/
4100+ pr_debug("start adbd only in ADB composition\n");
4101+ return -ENODEV;
4102+ }
4103
4104 config->data = ffs;
4105 config->opened = true;
4106+ /* Save dev in case the adb function will get disabled */
4107+ config->dev = dev;
4108
4109 if (config->enabled)
4110 android_enable(dev);
4111
4112-err:
4113 mutex_unlock(&dev->mutex);
4114- return ret;
4115+
4116+ return 0;
4117 }
4118
4119 static void functionfs_closed_callback(struct ffs_data *ffs)
4120 {
4121- struct android_dev *dev = _android_dev;
4122+ struct android_dev *dev = ffs_function.android_dev;
4123 struct functionfs_config *config = ffs_function.config;
4124
4125- mutex_lock(&dev->mutex);
4126+ /*
4127+ * In case new composition is without ADB or ADB got disabled by the
4128+ * time ffs_daemon was stopped then use saved one
4129+ */
4130+ if (!dev)
4131+ dev = config->dev;
4132
4133- if (config->enabled)
4134+ /* fatal-error: It should never happen */
4135+ if (!dev)
4136+ pr_err("adb_closed_callback: config->dev is NULL");
4137+
4138+ if (dev)
4139+ mutex_lock(&dev->mutex);
4140+
4141+ if (config->enabled && dev)
4142 android_disable(dev);
4143
4144+ config->dev = NULL;
4145+
4146 config->opened = false;
4147 config->data = NULL;
4148
4149 functionfs_unbind(ffs);
4150- /* Workaround to decrement the next_string_id
4151- * Issue: The next_string_id was never decremented
4152- * and when next_string_id = 254 USB connection fails
4153- */
4154- dev->cdev->next_string_id -= ffs->strings_count;
4155
4156- mutex_unlock(&dev->mutex);
4157+ if (dev)
4158+ mutex_unlock(&dev->mutex);
4159 }
4160
4161 static void *functionfs_acquire_dev_callback(const char *dev_name)
4162@@ -401,6 +702,8 @@ static void functionfs_release_dev_callback(struct ffs_data *ffs_data)
4163 {
4164 }
4165
4166+/* ACM */
4167+static char acm_transports[32]; /*enabled ACM ports - "tty[,sdio]"*/
4168 #define MAX_ACM_INSTANCES 4
4169 struct acm_function_config {
4170 int instances;
4171@@ -413,8 +716,6 @@ static int
4172 acm_function_init(struct android_usb_function *f,
4173 struct usb_composite_dev *cdev)
4174 {
4175- int i;
4176- int ret;
4177 struct acm_function_config *config;
4178
4179 config = kzalloc(sizeof(struct acm_function_config), GFP_KERNEL);
4180@@ -422,26 +723,7 @@ acm_function_init(struct android_usb_function *f,
4181 return -ENOMEM;
4182 f->config = config;
4183
4184- for (i = 0; i < MAX_ACM_INSTANCES; i++) {
4185- config->f_acm_inst[i] = usb_get_function_instance("acm");
4186- if (IS_ERR(config->f_acm_inst[i])) {
4187- ret = PTR_ERR(config->f_acm_inst[i]);
4188- goto err_usb_get_function_instance;
4189- }
4190- config->f_acm[i] = usb_get_function(config->f_acm_inst[i]);
4191- if (IS_ERR(config->f_acm[i])) {
4192- ret = PTR_ERR(config->f_acm[i]);
4193- goto err_usb_get_function;
4194- }
4195- }
4196 return 0;
4197-err_usb_get_function_instance:
4198- while (i-- > 0) {
4199- usb_put_function(config->f_acm[i]);
4200-err_usb_get_function:
4201- usb_put_function_instance(config->f_acm_inst[i]);
4202- }
4203- return ret;
4204 }
4205
4206 static void acm_function_cleanup(struct android_usb_function *f)
4207@@ -449,7 +731,8 @@ static void acm_function_cleanup(struct android_usb_function *f)
4208 int i;
4209 struct acm_function_config *config = f->config;
4210
4211- for (i = 0; i < MAX_ACM_INSTANCES; i++) {
4212+ acm_port_cleanup();
4213+ for (i = 0; i < config->instances_on; i++) {
4214 usb_put_function(config->f_acm[i]);
4215 usb_put_function_instance(config->f_acm_inst[i]);
4216 }
4217@@ -461,14 +744,59 @@ static int
4218 acm_function_bind_config(struct android_usb_function *f,
4219 struct usb_configuration *c)
4220 {
4221- int i;
4222- int ret = 0;
4223+ char *name;
4224+ char buf[32], *b;
4225+ int err = -1, i;
4226+ static int acm_initialized, ports;
4227 struct acm_function_config *config = f->config;
4228
4229- config->instances_on = config->instances;
4230- for (i = 0; i < config->instances_on; i++) {
4231- ret = usb_add_function(c, config->f_acm[i]);
4232- if (ret) {
4233+ if (acm_initialized)
4234+ goto bind_config;
4235+
4236+ acm_initialized = 1;
4237+ strlcpy(buf, acm_transports, sizeof(buf));
4238+ b = strim(buf);
4239+
4240+ while (b) {
4241+ name = strsep(&b, ",");
4242+
4243+ if (name) {
4244+ err = acm_init_port(ports, name);
4245+ if (err) {
4246+ pr_err("acm: Cannot open port '%s'", name);
4247+ goto out;
4248+ }
4249+ ports++;
4250+ if (ports >= MAX_ACM_INSTANCES) {
4251+ pr_err("acm: max ports reached '%s'", name);
4252+ goto out;
4253+ }
4254+ }
4255+ }
4256+ err = acm_port_setup(c);
4257+ if (err) {
4258+ pr_err("acm: Cannot setup transports");
4259+ goto out;
4260+ }
4261+
4262+ for (i = 0; i < ports; i++) {
4263+ config->f_acm_inst[i] = usb_get_function_instance("acm");
4264+ if (IS_ERR(config->f_acm_inst[i])) {
4265+ err = PTR_ERR(config->f_acm_inst[i]);
4266+ goto err_usb_get_function_instance;
4267+ }
4268+ config->f_acm[i] = usb_get_function(config->f_acm_inst[i]);
4269+ if (IS_ERR(config->f_acm[i])) {
4270+ err = PTR_ERR(config->f_acm[i]);
4271+ goto err_usb_get_function;
4272+ }
4273+ }
4274+ config->instances_on = ports;
4275+
4276+bind_config:
4277+ for (i = 0; i < ports; i++) {
4278+ err = usb_add_function(c, config->f_acm[i]);
4279+ if (err) {
4280 pr_err("Could not bind acm%u config\n", i);
4281 goto err_usb_add_function;
4282 }
4283@@ -479,35 +807,41 @@ acm_function_bind_config(struct android_usb_function *f,
4284 err_usb_add_function:
4285 while (i-- > 0)
4286 usb_remove_function(c, config->f_acm[i]);
4287- return ret;
4288+
4289+ config->instances_on = 0;
4290+ return err;
4291+
4292+err_usb_get_function_instance:
4293+ while (i-- > 0) {
4294+ usb_put_function(config->f_acm[i]);
4295+err_usb_get_function:
4296+ usb_put_function_instance(config->f_acm_inst[i]);
4297+ }
4298+
4299+out:
4300+ config->instances_on = 0;
4301+ return err;
4302 }
4303
4304-static ssize_t acm_instances_show(struct device *dev,
4305- struct device_attribute *attr, char *buf)
4306+static void acm_function_unbind_config(struct android_usb_function *f,
4307+ struct usb_configuration *c)
4308 {
4309- struct android_usb_function *f = dev_get_drvdata(dev);
4310 struct acm_function_config *config = f->config;
4311- return sprintf(buf, "%d\n", config->instances);
4312+ config->instances_on = 0;
4313 }
4314
4315-static ssize_t acm_instances_store(struct device *dev,
4316- struct device_attribute *attr, const char *buf, size_t size)
4317+static ssize_t acm_transports_store(
4318+ struct device *device, struct device_attribute *attr,
4319+ const char *buff, size_t size)
4320 {
4321- struct android_usb_function *f = dev_get_drvdata(dev);
4322- struct acm_function_config *config = f->config;
4323- int value;
4324+ strlcpy(acm_transports, buff, sizeof(acm_transports));
4325
4326- sscanf(buf, "%d", &value);
4327- if (value > MAX_ACM_INSTANCES)
4328- value = MAX_ACM_INSTANCES;
4329- config->instances = value;
4330 return size;
4331 }
4332
4333-static DEVICE_ATTR(instances, S_IRUGO | S_IWUSR, acm_instances_show,
4334- acm_instances_store);
4335+static DEVICE_ATTR(acm_transports, S_IWUSR, NULL, acm_transports_store);
4336 static struct device_attribute *acm_function_attributes[] = {
4337- &dev_attr_instances,
4338+ &dev_attr_acm_transports,
4339 NULL
4340 };
4341
4342@@ -516,151 +850,1073 @@ static struct android_usb_function acm_function = {
4343 .init = acm_function_init,
4344 .cleanup = acm_function_cleanup,
4345 .bind_config = acm_function_bind_config,
4346+ .unbind_config = acm_function_unbind_config,
4347 .attributes = acm_function_attributes,
4348 };
4349
4350-#ifdef CONFIG_USB_GADGET_GG
4351-#define MAX_GG_INSTANCES 2
4352-struct gg_function_config {
4353- int instances;
4354- int instances_on;
4355- struct usb_function *f_gg[MAX_GG_INSTANCES];
4356- struct usb_function_instance *f_gg_inst[MAX_GG_INSTANCES];
4357+/* RMNET_SMD */
4358+static int rmnet_smd_function_bind_config(struct android_usb_function *f,
4359+ struct usb_configuration *c)
4360+{
4361+ return rmnet_smd_bind_config(c);
4362+}
4363+
4364+static struct android_usb_function rmnet_smd_function = {
4365+ .name = "rmnet_smd",
4366+ .bind_config = rmnet_smd_function_bind_config,
4367 };
4368
4369-static int gg_function_init(struct android_usb_function *f,
4370- struct usb_composite_dev *cdev)
4371-{
4372- int i;
4373- int ret;
4374- struct gg_function_config *config;
4375+/*rmnet transport string format(per port):"ctrl0,data0,ctrl1,data1..." */
4376+#define MAX_XPORT_STR_LEN 50
4377+static char rmnet_transports[MAX_XPORT_STR_LEN];
4378
4379- config = kzalloc(sizeof(struct gg_function_config), GFP_KERNEL);
4380- if (!config)
4381- return -ENOMEM;
4382- f->config = config;
4383+/*rmnet transport name string - "rmnet_hsic[,rmnet_hsusb]" */
4384+static char rmnet_xport_names[MAX_XPORT_STR_LEN];
4385
4386- for (i = 0; i < MAX_GG_INSTANCES; i++) {
4387- config->f_gg_inst[i] = usb_get_function_instance("gg");
4388- if (IS_ERR(config->f_gg_inst[i])) {
4389- ret = PTR_ERR(config->f_gg_inst[i]);
4390- goto err_usb_get_function_instance;
4391- }
4392- config->f_gg[i] = usb_get_function(config->f_gg_inst[i]);
4393- if (IS_ERR(config->f_gg[i])) {
4394- ret = PTR_ERR(config->f_gg[i]);
4395- goto err_usb_get_function;
4396- }
4397- }
4398- return 0;
4399-err_usb_get_function_instance:
4400- while (i-- > 0) {
4401- usb_put_function(config->f_gg[i]);
4402-err_usb_get_function:
4403- usb_put_function_instance(config->f_gg_inst[i]);
4404- }
4405- return ret;
4406-}
4407+/*qdss transport string format(per port):"bam [, hsic]" */
4408+static char qdss_transports[MAX_XPORT_STR_LEN];
4409
4410-static void gg_function_cleanup(struct android_usb_function *f)
4411-{
4412- int i;
4413- struct gg_function_config *config = f->config;
4414+/*qdss transport name string - "qdss_bam [, qdss_hsic]" */
4415+static char qdss_xport_names[MAX_XPORT_STR_LEN];
4416
4417- for (i = 0; i < MAX_GG_INSTANCES; i++) {
4418- usb_put_function(config->f_gg[i]);
4419- usb_put_function_instance(config->f_gg_inst[i]);
4420- }
4421- kfree(f->config);
4422- f->config = NULL;
4423+/*qdss debug interface setting 0: disable 1:enable */
4424+static bool qdss_debug_intf;
4425+
4426+static void rmnet_function_cleanup(struct android_usb_function *f)
4427+{
4428+ frmnet_cleanup();
4429 }
4430
4431-static int gg_function_bind_config(struct android_usb_function *f,
4432- struct usb_configuration *c)
4433+static int rmnet_function_bind_config(struct android_usb_function *f,
4434+ struct usb_configuration *c)
4435 {
4436 int i;
4437- int ret = 0;
4438- struct gg_function_config *config = f->config;
4439+ int err = 0;
4440+ char *ctrl_name;
4441+ char *data_name;
4442+ char *tname = NULL;
4443+ char buf[MAX_XPORT_STR_LEN], *b;
4444+ char xport_name_buf[MAX_XPORT_STR_LEN], *tb;
4445+ static int rmnet_initialized, ports;
4446+
4447+ if (!rmnet_initialized) {
4448+ rmnet_initialized = 1;
4449+ strlcpy(buf, rmnet_transports, sizeof(buf));
4450+ b = strim(buf);
4451+
4452+ strlcpy(xport_name_buf, rmnet_xport_names,
4453+ sizeof(xport_name_buf));
4454+ tb = strim(xport_name_buf);
4455+
4456+ while (b) {
4457+ ctrl_name = strsep(&b, ",");
4458+ data_name = strsep(&b, ",");
4459+ if (ctrl_name && data_name) {
4460+ if (tb)
4461+ tname = strsep(&tb, ",");
4462+ err = frmnet_init_port(ctrl_name, data_name,
4463+ tname);
4464+ if (err) {
4465+ pr_err("rmnet: Cannot open ctrl port:"
4466+ "'%s' data port:'%s'\n",
4467+ ctrl_name, data_name);
4468+ goto out;
4469+ }
4470+ ports++;
4471+ }
4472+ }
4473
4474- config->instances_on = config->instances;
4475- for (i = 0; i < config->instances_on; i++) {
4476- ret = usb_add_function(c, config->f_gg[i]);
4477- if (ret) {
4478- pr_err("Could not bind gg%u config\n", i);
4479- goto err_usb_add_function;
4480+ err = rmnet_gport_setup();
4481+ if (err) {
4482+ pr_err("rmnet: Cannot setup transports");
4483+ goto out;
4484 }
4485 }
4486
4487- return 0;
4488+ for (i = 0; i < ports; i++) {
4489+ err = frmnet_bind_config(c, i);
4490+ if (err) {
4491+ pr_err("Could not bind rmnet%u config\n", i);
4492+ break;
4493+ }
4494+ }
4495+out:
4496+ return err;
4497+}
4498
4499-err_usb_add_function:
4500- while (i-- > 0)
4501- usb_remove_function(c, config->f_gg[i]);
4502- return ret;
4503+static void rmnet_function_unbind_config(struct android_usb_function *f,
4504+ struct usb_configuration *c)
4505+{
4506+ frmnet_unbind_config();
4507 }
4508
4509-static ssize_t gg_instances_show(struct device *dev,
4510+static ssize_t rmnet_transports_show(struct device *dev,
4511 struct device_attribute *attr, char *buf)
4512 {
4513- struct android_usb_function *f = dev_get_drvdata(dev);
4514- struct gg_function_config *config = f->config;
4515- return sprintf(buf, "%d\n", config->instances);
4516+ return snprintf(buf, PAGE_SIZE, "%s\n", rmnet_transports);
4517 }
4518
4519-static ssize_t gg_instances_store(struct device *dev,
4520- struct device_attribute *attr, const char *buf, size_t size)
4521+static ssize_t rmnet_transports_store(
4522+ struct device *device, struct device_attribute *attr,
4523+ const char *buff, size_t size)
4524 {
4525- struct android_usb_function *f = dev_get_drvdata(dev);
4526- struct gg_function_config *config = f->config;
4527- int value;
4528+ strlcpy(rmnet_transports, buff, sizeof(rmnet_transports));
4529
4530- sscanf(buf, "%d", &value);
4531- if (value > MAX_GG_INSTANCES)
4532- value = MAX_GG_INSTANCES;
4533- config->instances = value;
4534 return size;
4535 }
4536
4537-static DEVICE_ATTR(gg_instances, S_IRUGO | S_IWUSR, gg_instances_show,
4538- gg_instances_store);
4539-static struct device_attribute *gg_function_attributes[] = {
4540- &dev_attr_gg_instances,
4541- NULL
4542-};
4543-
4544-static struct android_usb_function gg_function = {
4545- .name = "gg",
4546- .init = gg_function_init,
4547- .cleanup = gg_function_cleanup,
4548- .bind_config = gg_function_bind_config,
4549- .attributes = gg_function_attributes,
4550-};
4551-#endif
4552-
4553-static int
4554-mtp_function_init(struct android_usb_function *f,
4555- struct usb_composite_dev *cdev)
4556+static ssize_t rmnet_xport_names_show(struct device *dev,
4557+ struct device_attribute *attr, char *buf)
4558 {
4559- return mtp_setup();
4560+ return snprintf(buf, PAGE_SIZE, "%s\n", rmnet_xport_names);
4561 }
4562
4563-static void mtp_function_cleanup(struct android_usb_function *f)
4564+static ssize_t rmnet_xport_names_store(
4565+ struct device *device, struct device_attribute *attr,
4566+ const char *buff, size_t size)
4567 {
4568- mtp_cleanup();
4569+ strlcpy(rmnet_xport_names, buff, sizeof(rmnet_xport_names));
4570+
4571+ return size;
4572 }
4573
4574-static int
4575-mtp_function_bind_config(struct android_usb_function *f,
4576- struct usb_configuration *c)
4577+static struct device_attribute dev_attr_rmnet_transports =
4578+ __ATTR(transports, S_IRUGO | S_IWUSR,
4579+ rmnet_transports_show,
4580+ rmnet_transports_store);
4581+
4582+static struct device_attribute dev_attr_rmnet_xport_names =
4583+ __ATTR(transport_names, S_IRUGO | S_IWUSR,
4584+ rmnet_xport_names_show,
4585+ rmnet_xport_names_store);
4586+
4587+static struct device_attribute *rmnet_function_attributes[] = {
4588+ &dev_attr_rmnet_transports,
4589+ &dev_attr_rmnet_xport_names,
4590+ NULL };
4591+
4592+static struct android_usb_function rmnet_function = {
4593+ .name = "rmnet",
4594+ .cleanup = rmnet_function_cleanup,
4595+ .bind_config = rmnet_function_bind_config,
4596+ .unbind_config = rmnet_function_unbind_config,
4597+ .attributes = rmnet_function_attributes,
4598+};
4599+
4600+static void gps_function_cleanup(struct android_usb_function *f)
4601 {
4602- return mtp_bind_config(c, false);
4603+ gps_cleanup();
4604 }
4605
4606-static int
4607-ptp_function_init(struct android_usb_function *f,
4608- struct usb_composite_dev *cdev)
4609+static int gps_function_bind_config(struct android_usb_function *f,
4610+ struct usb_configuration *c)
4611 {
4612- /* nothing to do - initialization is handled by mtp_function_init */
4613+ int err;
4614+ static int gps_initialized;
4615+
4616+ if (!gps_initialized) {
4617+ gps_initialized = 1;
4618+ err = gps_init_port();
4619+ if (err) {
4620+ pr_err("gps: Cannot init gps port");
4621+ return err;
4622+ }
4623+ }
4624+
4625+ err = gps_gport_setup();
4626+ if (err) {
4627+ pr_err("gps: Cannot setup transports");
4628+ return err;
4629+ }
4630+ err = gps_bind_config(c);
4631+ if (err) {
4632+ pr_err("Could not bind gps config\n");
4633+ return err;
4634+ }
4635+
4636+ return 0;
4637+}
4638+
4639+static struct android_usb_function gps_function = {
4640+ .name = "gps",
4641+ .cleanup = gps_function_cleanup,
4642+ .bind_config = gps_function_bind_config,
4643+};
4644+
4645+/* ncm */
4646+struct ncm_function_config {
4647+ u8 ethaddr[ETH_ALEN];
4648+ struct eth_dev *dev;
4649+};
4650+static int
4651+ncm_function_init(struct android_usb_function *f, struct usb_composite_dev *c)
4652+{
4653+ f->config = kzalloc(sizeof(struct ncm_function_config), GFP_KERNEL);
4654+ if (!f->config)
4655+ return -ENOMEM;
4656+
4657+ return 0;
4658+}
4659+
4660+static void ncm_function_cleanup(struct android_usb_function *f)
4661+{
4662+ kfree(f->config);
4663+ f->config = NULL;
4664+}
4665+
4666+static int
4667+ncm_function_bind_config(struct android_usb_function *f,
4668+ struct usb_configuration *c)
4669+{
4670+ struct ncm_function_config *ncm = f->config;
4671+ int ret;
4672+ struct eth_dev *dev;
4673+
4674+ if (!ncm) {
4675+ pr_err("%s: ncm config is null\n", __func__);
4676+ return -EINVAL;
4677+ }
4678+
4679+ pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
4680+ ncm->ethaddr[0], ncm->ethaddr[1], ncm->ethaddr[2],
4681+ ncm->ethaddr[3], ncm->ethaddr[4], ncm->ethaddr[5]);
4682+
4683+ dev = gether_setup_name(c->cdev->gadget, ncm->ethaddr, "ncm");
4684+ if (IS_ERR(dev)) {
4685+ ret = PTR_ERR(dev);
4686+ pr_err("%s: gether setup failed err:%d\n", __func__, ret);
4687+ return ret;
4688+ }
4689+ ncm->dev = dev;
4690+
4691+ ret = ncm_bind_config(c, ncm->ethaddr, dev);
4692+ if (ret) {
4693+ pr_err("%s: ncm bind config failed err:%d", __func__, ret);
4694+ gether_cleanup(dev);
4695+ return ret;
4696+ }
4697+
4698+ return ret;
4699+}
4700+
4701+static void ncm_function_unbind_config(struct android_usb_function *f,
4702+ struct usb_configuration *c)
4703+{
4704+ struct ncm_function_config *ncm = f->config;
4705+ gether_cleanup(ncm->dev);
4706+}
4707+
4708+static ssize_t ncm_ethaddr_show(struct device *dev,
4709+ struct device_attribute *attr, char *buf)
4710+{
4711+ struct android_usb_function *f = dev_get_drvdata(dev);
4712+ struct ncm_function_config *ncm = f->config;
4713+ return snprintf(buf, PAGE_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x\n",
4714+ ncm->ethaddr[0], ncm->ethaddr[1], ncm->ethaddr[2],
4715+ ncm->ethaddr[3], ncm->ethaddr[4], ncm->ethaddr[5]);
4716+}
4717+
4718+static ssize_t ncm_ethaddr_store(struct device *dev,
4719+ struct device_attribute *attr, const char *buf, size_t size)
4720+{
4721+ struct android_usb_function *f = dev_get_drvdata(dev);
4722+ struct ncm_function_config *ncm = f->config;
4723+
4724+ if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
4725+ (int *)&ncm->ethaddr[0], (int *)&ncm->ethaddr[1],
4726+ (int *)&ncm->ethaddr[2], (int *)&ncm->ethaddr[3],
4727+ (int *)&ncm->ethaddr[4], (int *)&ncm->ethaddr[5]) == 6)
4728+ return size;
4729+ return -EINVAL;
4730+}
4731+
4732+static DEVICE_ATTR(ncm_ethaddr, S_IRUGO | S_IWUSR, ncm_ethaddr_show,
4733+ ncm_ethaddr_store);
4734+static struct device_attribute *ncm_function_attributes[] = {
4735+ &dev_attr_ncm_ethaddr,
4736+ NULL
4737+};
4738+
4739+static struct android_usb_function ncm_function = {
4740+ .name = "ncm",
4741+ .init = ncm_function_init,
4742+ .cleanup = ncm_function_cleanup,
4743+ .bind_config = ncm_function_bind_config,
4744+ .unbind_config = ncm_function_unbind_config,
4745+ .attributes = ncm_function_attributes,
4746+};
4747+/* ecm transport string */
4748+static char ecm_transports[MAX_XPORT_STR_LEN];
4749+
4750+struct ecm_function_config {
4751+ u8 ethaddr[ETH_ALEN];
4752+ struct eth_dev *dev;
4753+};
4754+
4755+static int ecm_function_init(struct android_usb_function *f,
4756+ struct usb_composite_dev *cdev)
4757+{
4758+ f->config = kzalloc(sizeof(struct ecm_function_config), GFP_KERNEL);
4759+ if (!f->config)
4760+ return -ENOMEM;
4761+ return 0;
4762+}
4763+
4764+static int ecm_qc_function_init(struct android_usb_function *f,
4765+ struct usb_composite_dev *cdev)
4766+{
4767+ f->config = kzalloc(sizeof(struct ecm_function_config), GFP_KERNEL);
4768+ if (!f->config)
4769+ return -ENOMEM;
4770+ return ecm_qc_init();
4771+}
4772+static void ecm_function_cleanup(struct android_usb_function *f)
4773+{
4774+ kfree(f->config);
4775+ f->config = NULL;
4776+}
4777+
4778+static int ecm_qc_function_bind_config(struct android_usb_function *f,
4779+ struct usb_configuration *c)
4780+{
4781+ int ret;
4782+ char *trans;
4783+ struct ecm_function_config *ecm = f->config;
4784+
4785+ if (!ecm) {
4786+ pr_err("%s: ecm_pdata\n", __func__);
4787+ return -EINVAL;
4788+ }
4789+
4790+ pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
4791+ ecm->ethaddr[0], ecm->ethaddr[1], ecm->ethaddr[2],
4792+ ecm->ethaddr[3], ecm->ethaddr[4], ecm->ethaddr[5]);
4793+
4794+ pr_debug("%s: ecm_transport is %s", __func__, ecm_transports);
4795+
4796+ trans = strim(ecm_transports);
4797+ if (strcmp("BAM2BAM_IPA", trans)) {
4798+ ret = gether_qc_setup_name(c->cdev->gadget,
4799+ ecm->ethaddr, "ecm");
4800+ if (ret) {
4801+ pr_err("%s: gether_setup failed\n", __func__);
4802+ return ret;
4803+ }
4804+ }
4805+
4806+ return ecm_qc_bind_config(c, ecm->ethaddr, trans);
4807+}
4808+
4809+static void ecm_qc_function_unbind_config(struct android_usb_function *f,
4810+ struct usb_configuration *c)
4811+{
4812+ char *trans = strim(ecm_transports);
4813+
4814+ if (strcmp("BAM2BAM_IPA", trans)) {
4815+ bam_data_flush_workqueue();
4816+ gether_qc_cleanup_name("ecm0");
4817+ }
4818+}
4819+
4820+static ssize_t ecm_ethaddr_show(struct device *dev,
4821+ struct device_attribute *attr, char *buf)
4822+{
4823+ struct android_usb_function *f = dev_get_drvdata(dev);
4824+ struct ecm_function_config *ecm = f->config;
4825+ return snprintf(buf, PAGE_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x\n",
4826+ ecm->ethaddr[0], ecm->ethaddr[1], ecm->ethaddr[2],
4827+ ecm->ethaddr[3], ecm->ethaddr[4], ecm->ethaddr[5]);
4828+}
4829+
4830+static ssize_t ecm_ethaddr_store(struct device *dev,
4831+ struct device_attribute *attr, const char *buf, size_t size)
4832+{
4833+ struct android_usb_function *f = dev_get_drvdata(dev);
4834+ struct ecm_function_config *ecm = f->config;
4835+
4836+ if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
4837+ (int *)&ecm->ethaddr[0], (int *)&ecm->ethaddr[1],
4838+ (int *)&ecm->ethaddr[2], (int *)&ecm->ethaddr[3],
4839+ (int *)&ecm->ethaddr[4], (int *)&ecm->ethaddr[5]) == 6)
4840+ return size;
4841+ return -EINVAL;
4842+}
4843+
4844+static DEVICE_ATTR(ecm_ethaddr, S_IRUGO | S_IWUSR, ecm_ethaddr_show,
4845+ ecm_ethaddr_store);
4846+
4847+static ssize_t ecm_transports_show(struct device *dev,
4848+ struct device_attribute *attr, char *buf)
4849+{
4850+ return snprintf(buf, PAGE_SIZE, "%s\n", ecm_transports);
4851+}
4852+
4853+static ssize_t ecm_transports_store(struct device *dev,
4854+ struct device_attribute *attr, const char *buf, size_t size)
4855+{
4856+ strlcpy(ecm_transports, buf, sizeof(ecm_transports));
4857+ return size;
4858+}
4859+
4860+static DEVICE_ATTR(ecm_transports, S_IRUGO | S_IWUSR, ecm_transports_show,
4861+ ecm_transports_store);
4862+
4863+static struct device_attribute *ecm_function_attributes[] = {
4864+ &dev_attr_ecm_transports,
4865+ &dev_attr_ecm_ethaddr,
4866+ NULL
4867+};
4868+
4869+static struct android_usb_function ecm_qc_function = {
4870+ .name = "ecm_qc",
4871+ .init = ecm_qc_function_init,
4872+ .cleanup = ecm_function_cleanup,
4873+ .bind_config = ecm_qc_function_bind_config,
4874+ .unbind_config = ecm_qc_function_unbind_config,
4875+ .attributes = ecm_function_attributes,
4876+};
4877+
4878+/* MBIM - used with BAM */
4879+#define MAX_MBIM_INSTANCES 1
4880+
4881+static int mbim_function_init(struct android_usb_function *f,
4882+ struct usb_composite_dev *cdev)
4883+{
4884+ return mbim_init(MAX_MBIM_INSTANCES);
4885+}
4886+
4887+static void mbim_function_cleanup(struct android_usb_function *f)
4888+{
4889+ fmbim_cleanup();
4890+}
4891+
4892+
4893+/* mbim transport string */
4894+static char mbim_transports[MAX_XPORT_STR_LEN];
4895+
4896+static int mbim_function_bind_config(struct android_usb_function *f,
4897+ struct usb_configuration *c)
4898+{
4899+ char *trans;
4900+
4901+ pr_debug("%s: mbim transport is %s", __func__, mbim_transports);
4902+ trans = strim(mbim_transports);
4903+ return mbim_bind_config(c, 0, trans);
4904+}
4905+
4906+static void mbim_function_unbind_config(struct android_usb_function *f,
4907+ struct usb_configuration *c)
4908+{
4909+ char *trans = strim(mbim_transports);
4910+
4911+ if (strcmp("BAM2BAM_IPA", trans))
4912+ bam_data_flush_workqueue();
4913+}
4914+
4915+static int mbim_function_ctrlrequest(struct android_usb_function *f,
4916+ struct usb_composite_dev *cdev,
4917+ const struct usb_ctrlrequest *c)
4918+{
4919+ return mbim_ctrlrequest(cdev, c);
4920+}
4921+
4922+static ssize_t mbim_transports_show(struct device *dev,
4923+ struct device_attribute *attr, char *buf)
4924+{
4925+ return snprintf(buf, PAGE_SIZE, "%s\n", mbim_transports);
4926+}
4927+
4928+static ssize_t mbim_transports_store(struct device *dev,
4929+ struct device_attribute *attr, const char *buf, size_t size)
4930+{
4931+ strlcpy(mbim_transports, buf, sizeof(mbim_transports));
4932+ return size;
4933+}
4934+
4935+static DEVICE_ATTR(mbim_transports, S_IRUGO | S_IWUSR, mbim_transports_show,
4936+ mbim_transports_store);
4937+
4938+static ssize_t wMTU_show(struct device *dev,
4939+ struct device_attribute *attr, char *buf)
4940+{
4941+ return snprintf(buf, PAGE_SIZE, "%d\n", ext_mbb_desc.wMTU);
4942+}
4943+
4944+static ssize_t wMTU_store(struct device *dev,
4945+ struct device_attribute *attr, const char *buf, size_t size)
4946+{
4947+ int value;
4948+ if (sscanf(buf, "%d", &value) == 1) {
4949+ if (value < 0 || value > USHRT_MAX)
4950+ pr_err("illegal MTU %d, enter unsigned 16 bits\n",
4951+ value);
4952+ else
4953+ ext_mbb_desc.wMTU = cpu_to_le16(value);
4954+ return size;
4955+ }
4956+ return -EINVAL;
4957+}
4958+
4959+static DEVICE_ATTR(wMTU, S_IRUGO | S_IWUSR, wMTU_show,
4960+ wMTU_store);
4961+
4962+static struct device_attribute *mbim_function_attributes[] = {
4963+ &dev_attr_mbim_transports,
4964+ &dev_attr_wMTU,
4965+ NULL
4966+};
4967+
4968+static struct android_usb_function mbim_function = {
4969+ .name = "usb_mbim",
4970+ .cleanup = mbim_function_cleanup,
4971+ .bind_config = mbim_function_bind_config,
4972+ .unbind_config = mbim_function_unbind_config,
4973+ .init = mbim_function_init,
4974+ .ctrlrequest = mbim_function_ctrlrequest,
4975+ .attributes = mbim_function_attributes,
4976+};
4977+
4978+#ifdef CONFIG_SND_PCM
4979+/* PERIPHERAL AUDIO */
4980+static int audio_function_bind_config(struct android_usb_function *f,
4981+ struct usb_configuration *c)
4982+{
4983+ return audio_bind_config(c);
4984+}
4985+
4986+static struct android_usb_function audio_function = {
4987+ .name = "audio",
4988+ .bind_config = audio_function_bind_config,
4989+};
4990+#endif
4991+
4992+
4993+/* DIAG */
4994+static char diag_clients[32]; /*enabled DIAG clients- "diag[,diag_mdm]" */
4995+static ssize_t clients_store(
4996+ struct device *device, struct device_attribute *attr,
4997+ const char *buff, size_t size)
4998+{
4999+ strlcpy(diag_clients, buff, sizeof(diag_clients));
5000+
5001+ return size;
5002+}
5003+
5004+static DEVICE_ATTR(clients, S_IWUSR, NULL, clients_store);
5005+static struct device_attribute *diag_function_attributes[] =
5006+ { &dev_attr_clients, NULL };
5007+
5008+static int diag_function_init(struct android_usb_function *f,
5009+ struct usb_composite_dev *cdev)
5010+{
5011+ return diag_setup();
5012+}
5013+
5014+static void diag_function_cleanup(struct android_usb_function *f)
5015+{
5016+ diag_cleanup();
5017+}
5018+
5019+static int diag_function_bind_config(struct android_usb_function *f,
5020+ struct usb_configuration *c)
5021+{
5022+ char *name;
5023+ char buf[32], *b;
5024+ int once = 0, err = -1;
5025+ int (*notify)(uint32_t, const char *);
5026+ struct android_dev *dev = cdev_to_android_dev(c->cdev);
5027+
5028+ strlcpy(buf, diag_clients, sizeof(buf));
5029+ b = strim(buf);
5030+
5031+ while (b) {
5032+ notify = NULL;
5033+ name = strsep(&b, ",");
5034+ /* Allow only first diag channel to update pid and serial no */
5035+ if (!once++) {
5036+ if (dev->pdata && dev->pdata->update_pid_and_serial_num)
5037+ notify = dev->pdata->update_pid_and_serial_num;
5038+ else
5039+ notify = usb_diag_update_pid_and_serial_num;
5040+ }
5041+
5042+ if (name) {
5043+ err = diag_function_add(c, name, notify);
5044+ if (err)
5045+ pr_err("diag: Cannot open channel '%s'", name);
5046+ }
5047+ }
5048+
5049+ return err;
5050+}
5051+
5052+static struct android_usb_function diag_function = {
5053+ .name = "diag",
5054+ .init = diag_function_init,
5055+ .cleanup = diag_function_cleanup,
5056+ .bind_config = diag_function_bind_config,
5057+ .attributes = diag_function_attributes,
5058+};
5059+
5060+/* DEBUG */
5061+static int qdss_function_init(struct android_usb_function *f,
5062+ struct usb_composite_dev *cdev)
5063+{
5064+ return qdss_setup();
5065+}
5066+
5067+static void qdss_function_cleanup(struct android_usb_function *f)
5068+{
5069+ qdss_cleanup();
5070+}
5071+
5072+static int qdss_init_transports(int *portnum)
5073+{
5074+ char *ts_port;
5075+ char *tname = NULL;
5076+ char *ctrl_name = NULL;
5077+ char buf[MAX_XPORT_STR_LEN], *type;
5078+ char xport_name_buf[MAX_XPORT_STR_LEN], *tn;
5079+ int err = 0;
5080+
5081+ strlcpy(buf, qdss_transports, sizeof(buf));
5082+ type = strim(buf);
5083+
5084+ strlcpy(xport_name_buf, qdss_xport_names,
5085+ sizeof(xport_name_buf));
5086+ tn = strim(xport_name_buf);
5087+
5088+ pr_debug("%s: qdss_debug_intf = %d\n",
5089+ __func__, qdss_debug_intf);
5090+
5091+ /*
5092+ * QDSS function driver is being used for QDSS and DPL
5093+ * functionality. ctrl_name (i.e. ctrl xport) is optional
5094+ * whereas data transport name is mandatory to provide
5095+ * while using QDSS/DPL as part of USB composition.
5096+ */
5097+ while (type) {
5098+ ctrl_name = strsep(&type, ",");
5099+ ts_port = strsep(&type, ",");
5100+ if (!ts_port) {
5101+ pr_debug("%s:ctrl transport is not provided.\n",
5102+ __func__);
5103+ ts_port = ctrl_name;
5104+ ctrl_name = NULL;
5105+ }
5106+
5107+ if (ts_port) {
5108+ if (tn)
5109+ tname = strsep(&tn, ",");
5110+
5111+ err = qdss_init_port(
5112+ ctrl_name,
5113+ ts_port,
5114+ tname,
5115+ qdss_debug_intf);
5116+
5117+ if (err) {
5118+ pr_err("%s: Cannot open transport port:'%s'\n",
5119+ __func__, ts_port);
5120+ return err;
5121+ }
5122+ (*portnum)++;
5123+ } else {
5124+ pr_err("%s: No data transport name for QDSS port.\n",
5125+ __func__);
5126+ err = -ENODEV;
5127+ }
5128+ }
5129+ return err;
5130+}
5131+
5132+static int qdss_function_bind_config(struct android_usb_function *f,
5133+ struct usb_configuration *c)
5134+{
5135+ int i;
5136+ int err = 0;
5137+ static int qdss_initialized = 0, portsnum;
5138+
5139+ if (!qdss_initialized) {
5140+ qdss_initialized = 1;
5141+
5142+ err = qdss_init_transports(&portsnum);
5143+ if (err) {
5144+ pr_err("qdss: Cannot init transports");
5145+ goto out;
5146+ }
5147+
5148+ err = qdss_gport_setup();
5149+ if (err) {
5150+ pr_err("qdss: Cannot setup transports");
5151+ goto out;
5152+ }
5153+ }
5154+
5155+ pr_debug("%s: port number is %d\n", __func__, portsnum);
5156+
5157+ for (i = 0; i < portsnum; i++) {
5158+ err = qdss_bind_config(c, i);
5159+ if (err) {
5160+ pr_err("Could not bind qdss%u config\n", i);
5161+ break;
5162+ }
5163+ }
5164+out:
5165+ return err;
5166+}
5167+
5168+static ssize_t qdss_transports_show(struct device *dev,
5169+ struct device_attribute *attr, char *buf)
5170+{
5171+ return snprintf(buf, PAGE_SIZE, "%s\n", qdss_transports);
5172+}
5173+
5174+static ssize_t qdss_transports_store(
5175+ struct device *device, struct device_attribute *attr,
5176+ const char *buff, size_t size)
5177+{
5178+ strlcpy(qdss_transports, buff, sizeof(qdss_transports));
5179+
5180+ return size;
5181+}
5182+
5183+static ssize_t qdss_xport_names_show(struct device *dev,
5184+ struct device_attribute *attr, char *buf)
5185+{
5186+ return snprintf(buf, PAGE_SIZE, "%s\n", qdss_xport_names);
5187+}
5188+
5189+static ssize_t qdss_xport_names_store(
5190+ struct device *device, struct device_attribute *attr,
5191+ const char *buff, size_t size)
5192+{
5193+ strlcpy(qdss_xport_names, buff, sizeof(qdss_xport_names));
5194+ return size;
5195+}
5196+
5197+static ssize_t qdss_debug_intf_store(
5198+ struct device *device, struct device_attribute *attr,
5199+ const char *buff, size_t size)
5200+{
5201+ strtobool(buff, &qdss_debug_intf);
5202+ return size;
5203+}
5204+
5205+static ssize_t qdss_debug_intf_show(struct device *dev,
5206+ struct device_attribute *attr, char *buf)
5207+{
5208+ return snprintf(buf, PAGE_SIZE, "%d\n", qdss_debug_intf);
5209+}
5210+
5211+static struct device_attribute dev_attr_qdss_transports =
5212+ __ATTR(transports, S_IRUGO | S_IWUSR,
5213+ qdss_transports_show,
5214+ qdss_transports_store);
5215+
5216+static struct device_attribute dev_attr_qdss_xport_names =
5217+ __ATTR(transport_names, S_IRUGO | S_IWUSR,
5218+ qdss_xport_names_show,
5219+ qdss_xport_names_store);
5220+
5221+/* 1(enable)/0(disable) the qdss debug interface */
5222+static struct device_attribute dev_attr_qdss_debug_intf =
5223+ __ATTR(debug_intf, S_IRUGO | S_IWUSR,
5224+ qdss_debug_intf_show,
5225+ qdss_debug_intf_store);
5226+
5227+static struct device_attribute *qdss_function_attributes[] = {
5228+ &dev_attr_qdss_transports,
5229+ &dev_attr_qdss_xport_names,
5230+ &dev_attr_qdss_debug_intf,
5231+ NULL };
5232+
5233+static struct android_usb_function qdss_function = {
5234+ .name = "qdss",
5235+ .init = qdss_function_init,
5236+ .cleanup = qdss_function_cleanup,
5237+ .bind_config = qdss_function_bind_config,
5238+ .attributes = qdss_function_attributes,
5239+};
5240+
5241+/* SERIAL */
5242+#define MAX_SERIAL_INSTANCES 4
5243+struct serial_function_config {
5244+ int instances_on;
5245+ struct usb_function *f_serial[MAX_SERIAL_INSTANCES];
5246+ struct usb_function_instance *f_serial_inst[MAX_SERIAL_INSTANCES];
5247+};
5248+
5249+static char serial_transports[32]; /*enabled FSERIAL ports - "tty[,sdio]"*/
5250+static ssize_t serial_transports_store(
5251+ struct device *device, struct device_attribute *attr,
5252+ const char *buff, size_t size)
5253+{
5254+ strlcpy(serial_transports, buff, sizeof(serial_transports));
5255+
5256+ return size;
5257+}
5258+
5259+/*enabled FSERIAL transport names - "serial_hsic[,serial_hsusb]"*/
5260+static char serial_xport_names[32];
5261+static ssize_t serial_xport_names_store(
5262+ struct device *device, struct device_attribute *attr,
5263+ const char *buff, size_t size)
5264+{
5265+ strlcpy(serial_xport_names, buff, sizeof(serial_xport_names));
5266+
5267+ return size;
5268+}
5269+
5270+static ssize_t serial_xport_names_show(struct device *dev,
5271+ struct device_attribute *attr, char *buf)
5272+{
5273+ return snprintf(buf, PAGE_SIZE, "%s\n", serial_xport_names);
5274+}
5275+static ssize_t serial_modem_is_connected_show(
5276+ struct device *device, struct device_attribute *attr,
5277+ char *buff)
5278+{
5279+ unsigned int is_connected = gserial_is_connected();
5280+
5281+ return snprintf(buff, PAGE_SIZE, "%u\n", is_connected);
5282+}
5283+
5284+static ssize_t dun_w_softap_enable_show(
5285+ struct device *device, struct device_attribute *attr,
5286+ char *buff)
5287+{
5288+ unsigned int dun_w_softap_enable = gserial_is_dun_w_softap_enabled();
5289+
5290+ return snprintf(buff, PAGE_SIZE, "%u\n", dun_w_softap_enable);
5291+}
5292+
5293+static ssize_t dun_w_softap_enable_store(
5294+ struct device *device, struct device_attribute *attr,
5295+ const char *buff, size_t size)
5296+{
5297+ unsigned int dun_w_softap_enable;
5298+
5299+ sscanf(buff, "%u", &dun_w_softap_enable);
5300+
5301+ gserial_dun_w_softap_enable(dun_w_softap_enable);
5302+
5303+ return size;
5304+}
5305+
5306+static ssize_t dun_w_softap_active_show(
5307+ struct device *device, struct device_attribute *attr,
5308+ char *buff)
5309+{
5310+ unsigned int dun_w_softap_active = gserial_is_dun_w_softap_active();
5311+
5312+ return snprintf(buff, PAGE_SIZE, "%u\n", dun_w_softap_active);
5313+}
5314+
5315+static DEVICE_ATTR(is_connected_flag, S_IRUGO, serial_modem_is_connected_show,
5316+ NULL);
5317+static DEVICE_ATTR(dun_w_softap_enable, S_IRUGO | S_IWUSR,
5318+ dun_w_softap_enable_show, dun_w_softap_enable_store);
5319+static DEVICE_ATTR(dun_w_softap_active, S_IRUGO, dun_w_softap_active_show,
5320+ NULL);
5321+
5322+
5323+static DEVICE_ATTR(transports, S_IWUSR, NULL, serial_transports_store);
5324+static struct device_attribute dev_attr_serial_xport_names =
5325+ __ATTR(transport_names, S_IRUGO | S_IWUSR,
5326+ serial_xport_names_show,
5327+ serial_xport_names_store);
5328+
5329+static struct device_attribute *serial_function_attributes[] = {
5330+ &dev_attr_transports,
5331+ &dev_attr_serial_xport_names,
5332+ &dev_attr_is_connected_flag,
5333+ &dev_attr_dun_w_softap_enable,
5334+ &dev_attr_dun_w_softap_active,
5335+ NULL };
5336+
5337+static int serial_function_init(struct android_usb_function *f,
5338+ struct usb_composite_dev *cdev)
5339+{
5340+ struct serial_function_config *config;
5341+
5342+ config = kzalloc(sizeof(struct serial_function_config), GFP_KERNEL);
5343+ if (!config)
5344+ return -ENOMEM;
5345+
5346+ f->config = config;
5347+
5348+ return 0;
5349+}
5350+
5351+static void serial_function_cleanup(struct android_usb_function *f)
5352+{
5353+ int i;
5354+ struct serial_function_config *config = f->config;
5355+
5356+ gport_cleanup();
5357+ for (i = 0; i < config->instances_on; i++) {
5358+ usb_put_function(config->f_serial[i]);
5359+ usb_put_function_instance(config->f_serial_inst[i]);
5360+ }
5361+ kfree(f->config);
5362+ f->config = NULL;
5363+}
5364+
5365+static int serial_function_bind_config(struct android_usb_function *f,
5366+ struct usb_configuration *c)
5367+{
5368+ char *name, *xport_name = NULL;
5369+ char buf[32], *b, xport_name_buf[32], *tb;
5370+ int err = -1, i;
5371+ static int serial_initialized = 0, ports = 0;
5372+ struct serial_function_config *config = f->config;
5373+
5374+ if (serial_initialized)
5375+ goto bind_config;
5376+
5377+ serial_initialized = 1;
5378+ strlcpy(buf, serial_transports, sizeof(buf));
5379+ b = strim(buf);
5380+
5381+ strlcpy(xport_name_buf, serial_xport_names, sizeof(xport_name_buf));
5382+ tb = strim(xport_name_buf);
5383+
5384+ while (b) {
5385+ name = strsep(&b, ",");
5386+
5387+ if (name) {
5388+ if (tb)
5389+ xport_name = strsep(&tb, ",");
5390+ err = gserial_init_port(ports, name, xport_name);
5391+ if (err) {
5392+ pr_err("serial: Cannot open port '%s'", name);
5393+ goto out;
5394+ }
5395+ ports++;
5396+ if (ports >= MAX_SERIAL_INSTANCES) {
5397+ pr_err("serial: max ports reached '%s'", name);
5398+ goto out;
5399+ }
5400+ }
5401+ }
5402+ err = gport_setup(c);
5403+ if (err) {
5404+ pr_err("serial: Cannot setup transports");
5405+ goto out;
5406+ }
5407+
5408+ for (i = 0; i < ports; i++) {
5409+ config->f_serial_inst[i] = usb_get_function_instance("gser");
5410+ if (IS_ERR(config->f_serial_inst[i])) {
5411+ err = PTR_ERR(config->f_serial_inst[i]);
5412+ goto err_gser_usb_get_function_instance;
5413+ }
5414+ config->f_serial[i] = usb_get_function(config->f_serial_inst[i]);
5415+ if (IS_ERR(config->f_serial[i])) {
5416+ err = PTR_ERR(config->f_serial[i]);
5417+ goto err_gser_usb_get_function;
5418+ }
5419+ }
5420+ config->instances_on = ports;
5421+
5422+bind_config:
5423+ for (i = 0; i < ports; i++) {
5424+ err = usb_add_function(c, config->f_serial[i]);
5425+ if (err) {
5426+ pr_err("Could not bind gser%u config\n", i);
5427+ goto err_gser_usb_add_function;
5428+ }
5429+ }
5430+ return 0;
5431+
5432+err_gser_usb_add_function:
5433+ while (i-- > 0)
5434+ usb_remove_function(c, config->f_serial[i]);
5435+
5436+ return err;
5437+
5438+err_gser_usb_get_function_instance:
5439+ while (i-- > 0) {
5440+ usb_put_function(config->f_serial[i]);
5441+err_gser_usb_get_function:
5442+ usb_put_function_instance(config->f_serial_inst[i]);
5443+ }
5444+
5445+out:
5446+ return err;
5447+}
5448+
5449+static struct android_usb_function serial_function = {
5450+ .name = "serial",
5451+ .init = serial_function_init,
5452+ .cleanup = serial_function_cleanup,
5453+ .bind_config = serial_function_bind_config,
5454+ .attributes = serial_function_attributes,
5455+};
5456+
5457+/* CCID */
5458+static int ccid_function_init(struct android_usb_function *f,
5459+ struct usb_composite_dev *cdev)
5460+{
5461+ return ccid_setup();
5462+}
5463+
5464+static void ccid_function_cleanup(struct android_usb_function *f)
5465+{
5466+ ccid_cleanup();
5467+}
5468+
5469+static int ccid_function_bind_config(struct android_usb_function *f,
5470+ struct usb_configuration *c)
5471+{
5472+ return ccid_bind_config(c);
5473+}
5474+
5475+static struct android_usb_function ccid_function = {
5476+ .name = "ccid",
5477+ .init = ccid_function_init,
5478+ .cleanup = ccid_function_cleanup,
5479+ .bind_config = ccid_function_bind_config,
5480+};
5481+
5482+/* Charger */
5483+static int charger_function_bind_config(struct android_usb_function *f,
5484+ struct usb_configuration *c)
5485+{
5486+ return charger_bind_config(c);
5487+}
5488+
5489+static struct android_usb_function charger_function = {
5490+ .name = "charging",
5491+ .bind_config = charger_function_bind_config,
5492+};
5493+
5494+
5495+static int
5496+mtp_function_init(struct android_usb_function *f,
5497+ struct usb_composite_dev *cdev)
5498+{
5499+ return mtp_setup();
5500+}
5501+
5502+static void mtp_function_cleanup(struct android_usb_function *f)
5503+{
5504+ mtp_cleanup();
5505+}
5506+
5507+static int
5508+mtp_function_bind_config(struct android_usb_function *f,
5509+ struct usb_configuration *c)
5510+{
5511+ return mtp_bind_config(c, false);
5512+}
5513+
5514+static int
5515+ptp_function_init(struct android_usb_function *f,
5516+ struct usb_composite_dev *cdev)
5517+{
5518+ /* nothing to do - initialization is handled by mtp_function_init */
5519 return 0;
5520 }
5521
5522@@ -683,6 +1939,14 @@ static int mtp_function_ctrlrequest(struct android_usb_function *f,
5523 return mtp_ctrlrequest(cdev, c);
5524 }
5525
5526+static int ptp_function_ctrlrequest(struct android_usb_function *f,
5527+ struct usb_composite_dev *cdev,
5528+ const struct usb_ctrlrequest *c)
5529+{
5530+ return mtp_ctrlrequest(cdev, c);
5531+}
5532+
5533+
5534 static struct android_usb_function mtp_function = {
5535 .name = "mtp",
5536 .init = mtp_function_init,
5537@@ -697,12 +1961,17 @@ static struct android_usb_function ptp_function = {
5538 .init = ptp_function_init,
5539 .cleanup = ptp_function_cleanup,
5540 .bind_config = ptp_function_bind_config,
5541+ .ctrlrequest = ptp_function_ctrlrequest,
5542 };
5543
5544+/* rndis transport string */
5545+static char rndis_transports[MAX_XPORT_STR_LEN];
5546
5547 struct rndis_function_config {
5548 u8 ethaddr[ETH_ALEN];
5549 u32 vendorID;
5550+ u8 max_pkt_per_xfer;
5551+ u8 pkt_alignment_factor;
5552 char manufacturer[256];
5553 /* "Wireless" RNDIS; auto-detected by Windows */
5554 bool wceis;
5555@@ -725,6 +1994,27 @@ static void rndis_function_cleanup(struct android_usb_function *f)
5556 f->config = NULL;
5557 }
5558
5559+static int rndis_qc_function_init(struct android_usb_function *f,
5560+ struct usb_composite_dev *cdev)
5561+{
5562+ struct rndis_function_config *rndis;
5563+
5564+ rndis = kzalloc(sizeof(struct rndis_function_config), GFP_KERNEL);
5565+ if (!rndis)
5566+ return -ENOMEM;
5567+
5568+ rndis->wceis = true;
5569+
5570+ f->config = rndis;
5571+ return rndis_qc_init();
5572+}
5573+
5574+static void rndis_qc_function_cleanup(struct android_usb_function *f)
5575+{
5576+ rndis_qc_cleanup();
5577+ kfree(f->config);
5578+}
5579+
5580 static int
5581 rndis_function_bind_config(struct android_usb_function *f,
5582 struct usb_configuration *c)
5583@@ -742,7 +2032,11 @@ rndis_function_bind_config(struct android_usb_function *f,
5584 rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
5585 rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
5586
5587- dev = gether_setup_name(c->cdev->gadget, rndis->ethaddr, "rndis");
5588+ if (rndis->ethaddr[0])
5589+ dev = gether_setup_name(c->cdev->gadget, NULL, "rndis");
5590+ else
5591+ dev = gether_setup_name(c->cdev->gadget, rndis->ethaddr,
5592+ "rndis");
5593 if (IS_ERR(dev)) {
5594 ret = PTR_ERR(dev);
5595 pr_err("%s: gether_setup failed\n", __func__);
5596@@ -766,6 +2060,51 @@ rndis_function_bind_config(struct android_usb_function *f,
5597 rndis->manufacturer, rndis->dev);
5598 }
5599
5600+static int rndis_qc_function_bind_config(struct android_usb_function *f,
5601+ struct usb_configuration *c)
5602+{
5603+ int ret;
5604+ char *trans;
5605+ struct rndis_function_config *rndis = f->config;
5606+
5607+ if (!rndis) {
5608+ pr_err("%s: rndis_pdata\n", __func__);
5609+ return -EINVAL;
5610+ }
5611+
5612+ pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
5613+ rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
5614+ rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
5615+
5616+ pr_debug("%s: rndis_transport is %s", __func__, rndis_transports);
5617+
5618+ trans = strim(rndis_transports);
5619+ if (strcmp("BAM2BAM_IPA", trans)) {
5620+ ret = gether_qc_setup_name(c->cdev->gadget,
5621+ rndis->ethaddr, "rndis");
5622+ if (ret) {
5623+ pr_err("%s: gether_setup failed\n", __func__);
5624+ return ret;
5625+ }
5626+ }
5627+
5628+ if (rndis->wceis) {
5629+ /* "Wireless" RNDIS; auto-detected by Windows */
5630+ rndis_qc_iad_descriptor.bFunctionClass =
5631+ USB_CLASS_WIRELESS_CONTROLLER;
5632+ rndis_qc_iad_descriptor.bFunctionSubClass = 0x01;
5633+ rndis_qc_iad_descriptor.bFunctionProtocol = 0x03;
5634+ rndis_qc_control_intf.bInterfaceClass =
5635+ USB_CLASS_WIRELESS_CONTROLLER;
5636+ rndis_qc_control_intf.bInterfaceSubClass = 0x01;
5637+ rndis_qc_control_intf.bInterfaceProtocol = 0x03;
5638+ }
5639+
5640+ return rndis_qc_bind_config_vendor(c, rndis->ethaddr, rndis->vendorID,
5641+ rndis->manufacturer, rndis->max_pkt_per_xfer,
5642+ rndis->pkt_alignment_factor, trans);
5643+}
5644+
5645 static void rndis_function_unbind_config(struct android_usb_function *f,
5646 struct usb_configuration *c)
5647 {
5648@@ -773,12 +2112,24 @@ static void rndis_function_unbind_config(struct android_usb_function *f,
5649 gether_cleanup(rndis->dev);
5650 }
5651
5652+static void rndis_qc_function_unbind_config(struct android_usb_function *f,
5653+ struct usb_configuration *c)
5654+{
5655+ char *trans = strim(rndis_transports);
5656+
5657+ if (strcmp("BAM2BAM_IPA", trans)) {
5658+ bam_data_flush_workqueue();
5659+ gether_qc_cleanup_name("rndis0");
5660+ }
5661+}
5662+
5663 static ssize_t rndis_manufacturer_show(struct device *dev,
5664 struct device_attribute *attr, char *buf)
5665 {
5666 struct android_usb_function *f = dev_get_drvdata(dev);
5667 struct rndis_function_config *config = f->config;
5668- return sprintf(buf, "%s\n", config->manufacturer);
5669+
5670+ return snprintf(buf, PAGE_SIZE, "%s\n", config->manufacturer);
5671 }
5672
5673 static ssize_t rndis_manufacturer_store(struct device *dev,
5674@@ -789,7 +2140,8 @@ static ssize_t rndis_manufacturer_store(struct device *dev,
5675
5676 if (size >= sizeof(config->manufacturer))
5677 return -EINVAL;
5678- if (sscanf(buf, "%s", config->manufacturer) == 1)
5679+
5680+ if (sscanf(buf, "%255s", config->manufacturer) == 1)
5681 return size;
5682 return -1;
5683 }
5684@@ -802,7 +2154,8 @@ static ssize_t rndis_wceis_show(struct device *dev,
5685 {
5686 struct android_usb_function *f = dev_get_drvdata(dev);
5687 struct rndis_function_config *config = f->config;
5688- return sprintf(buf, "%d\n", config->wceis);
5689+
5690+ return snprintf(buf, PAGE_SIZE, "%d\n", config->wceis);
5691 }
5692
5693 static ssize_t rndis_wceis_store(struct device *dev,
5694@@ -827,7 +2180,8 @@ static ssize_t rndis_ethaddr_show(struct device *dev,
5695 {
5696 struct android_usb_function *f = dev_get_drvdata(dev);
5697 struct rndis_function_config *rndis = f->config;
5698- return sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5699+
5700+ return snprintf(buf, PAGE_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5701 rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
5702 rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
5703 }
5704@@ -843,263 +2197,249 @@ static ssize_t rndis_ethaddr_store(struct device *dev,
5705 (int *)&rndis->ethaddr[2], (int *)&rndis->ethaddr[3],
5706 (int *)&rndis->ethaddr[4], (int *)&rndis->ethaddr[5]) == 6)
5707 return size;
5708- return -EINVAL;
5709-}
5710-
5711-static DEVICE_ATTR(ethaddr, S_IRUGO | S_IWUSR, rndis_ethaddr_show,
5712- rndis_ethaddr_store);
5713-
5714-static ssize_t rndis_vendorID_show(struct device *dev,
5715- struct device_attribute *attr, char *buf)
5716-{
5717- struct android_usb_function *f = dev_get_drvdata(dev);
5718- struct rndis_function_config *config = f->config;
5719- return sprintf(buf, "%04x\n", config->vendorID);
5720-}
5721-
5722-static ssize_t rndis_vendorID_store(struct device *dev,
5723- struct device_attribute *attr, const char *buf, size_t size)
5724-{
5725- struct android_usb_function *f = dev_get_drvdata(dev);
5726- struct rndis_function_config *config = f->config;
5727- int value;
5728-
5729- if (sscanf(buf, "%04x", &value) == 1) {
5730- config->vendorID = value;
5731- return size;
5732- }
5733- return -EINVAL;
5734-}
5735-
5736-static DEVICE_ATTR(vendorID, S_IRUGO | S_IWUSR, rndis_vendorID_show,
5737- rndis_vendorID_store);
5738-
5739-static struct device_attribute *rndis_function_attributes[] = {
5740- &dev_attr_manufacturer,
5741- &dev_attr_wceis,
5742- &dev_attr_ethaddr,
5743- &dev_attr_vendorID,
5744- NULL
5745-};
5746-
5747-static struct android_usb_function rndis_function = {
5748- .name = "rndis",
5749- .init = rndis_function_init,
5750- .cleanup = rndis_function_cleanup,
5751- .bind_config = rndis_function_bind_config,
5752- .unbind_config = rndis_function_unbind_config,
5753- .attributes = rndis_function_attributes,
5754-};
5755-
5756-struct ncm_function_config {
5757- u8 ethaddr[ETH_ALEN];
5758- u32 vendorID;
5759- char manufacturer[256];
5760- u32 ntb_out_size;
5761- struct eth_dev *dev;
5762-};
5763-
5764-static int ncm_function_init(struct android_usb_function *f,
5765- struct usb_composite_dev *cdev)
5766-{
5767- f->config = kzalloc(sizeof(struct ncm_function_config), GFP_KERNEL);
5768- if (!f->config)
5769- return -ENOMEM;
5770- return 0;
5771-}
5772-
5773-static void ncm_function_cleanup(struct android_usb_function *f)
5774-{
5775- kfree(f->config);
5776- f->config = NULL;
5777-}
5778-
5779-static int ncm_function_bind_config(struct android_usb_function *f,
5780- struct usb_configuration *c)
5781-{
5782- int ret = 0;
5783- struct ncm_function_config *ncm = f->config;
5784- struct eth_dev *dev = NULL;
5785-
5786- if (!ncm) {
5787- pr_err("%s: ncm_pdata\n", __func__);
5788- return -1;
5789- }
5790-
5791- pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
5792- ncm->ethaddr[0], ncm->ethaddr[1], ncm->ethaddr[2],
5793- ncm->ethaddr[3], ncm->ethaddr[4], ncm->ethaddr[5]);
5794-
5795- dev = gether_setup_name(c->cdev->gadget, ncm->ethaddr, "ncm");
5796-
5797- if (IS_ERR(dev)) {
5798- ret = PTR_ERR(dev);
5799- pr_err("%s: gether_setup failed\n", __func__);
5800- return ret;
5801- }
5802- ncm->dev = dev;
5803-
5804- return ncm_bind_config(c, ncm->ethaddr, dev);
5805+ return -EINVAL;
5806 }
5807
5808-static void ncm_function_unbind_config(struct android_usb_function *f,
5809- struct usb_configuration *c)
5810-{
5811- struct ncm_function_config *ncm = f->config;
5812- gether_cleanup(ncm->dev);
5813-}
5814+static DEVICE_ATTR(ethaddr, S_IRUGO | S_IWUSR, rndis_ethaddr_show,
5815+ rndis_ethaddr_store);
5816
5817-static ssize_t ncm_manufacturer_show(struct device *dev,
5818+static ssize_t rndis_vendorID_show(struct device *dev,
5819 struct device_attribute *attr, char *buf)
5820 {
5821 struct android_usb_function *f = dev_get_drvdata(dev);
5822- struct ncm_function_config *config = f->config;
5823- return snprintf(buf, PAGE_SIZE, "%s\n", config->manufacturer);
5824+ struct rndis_function_config *config = f->config;
5825+
5826+ return snprintf(buf, PAGE_SIZE, "%04x\n", config->vendorID);
5827 }
5828
5829-static ssize_t ncm_manufacturer_store(struct device *dev,
5830+static ssize_t rndis_vendorID_store(struct device *dev,
5831 struct device_attribute *attr, const char *buf, size_t size)
5832 {
5833 struct android_usb_function *f = dev_get_drvdata(dev);
5834- struct ncm_function_config *config = f->config;
5835+ struct rndis_function_config *config = f->config;
5836+ int value;
5837
5838- if (size >= sizeof(config->manufacturer))
5839- return -EINVAL;
5840- if (sscanf(buf, "%s", config->manufacturer) == 1)
5841+ if (sscanf(buf, "%04x", &value) == 1) {
5842+ config->vendorID = value;
5843 return size;
5844- return -1;
5845+ }
5846+ return -EINVAL;
5847 }
5848
5849-static DEVICE_ATTR(manufacturer_ncm, S_IRUGO | S_IWUSR, ncm_manufacturer_show,
5850- ncm_manufacturer_store);
5851+static DEVICE_ATTR(vendorID, S_IRUGO | S_IWUSR, rndis_vendorID_show,
5852+ rndis_vendorID_store);
5853
5854-static ssize_t ncm_ethaddr_show(struct device *dev,
5855+static ssize_t rndis_max_pkt_per_xfer_show(struct device *dev,
5856 struct device_attribute *attr, char *buf)
5857 {
5858 struct android_usb_function *f = dev_get_drvdata(dev);
5859- struct ncm_function_config *ncm = f->config;
5860- return snprintf(buf, PAGE_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5861- ncm->ethaddr[0], ncm->ethaddr[1], ncm->ethaddr[2],
5862- ncm->ethaddr[3], ncm->ethaddr[4], ncm->ethaddr[5]);
5863+ struct rndis_function_config *config = f->config;
5864+ return snprintf(buf, PAGE_SIZE, "%d\n", config->max_pkt_per_xfer);
5865 }
5866
5867-static ssize_t ncm_ethaddr_store(struct device *dev,
5868+static ssize_t rndis_max_pkt_per_xfer_store(struct device *dev,
5869 struct device_attribute *attr, const char *buf, size_t size)
5870 {
5871 struct android_usb_function *f = dev_get_drvdata(dev);
5872- struct ncm_function_config *ncm = f->config;
5873+ struct rndis_function_config *config = f->config;
5874+ int value;
5875
5876- if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5877- (int *)&ncm->ethaddr[0], (int *)&ncm->ethaddr[1],
5878- (int *)&ncm->ethaddr[2], (int *)&ncm->ethaddr[3],
5879- (int *)&ncm->ethaddr[4], (int *)&ncm->ethaddr[5]) == 6)
5880+ if (sscanf(buf, "%d", &value) == 1) {
5881+ config->max_pkt_per_xfer = value;
5882 return size;
5883+ }
5884 return -EINVAL;
5885 }
5886
5887-static DEVICE_ATTR(ethaddr_ncm, S_IRUGO | S_IWUSR, ncm_ethaddr_show,
5888- ncm_ethaddr_store);
5889-
5890-static ssize_t ncm_vendorID_show(struct device *dev,
5891+static DEVICE_ATTR(max_pkt_per_xfer, S_IRUGO | S_IWUSR,
5892+ rndis_max_pkt_per_xfer_show,
5893+ rndis_max_pkt_per_xfer_store);
5894+static ssize_t rndis_transports_show(struct device *dev,
5895 struct device_attribute *attr, char *buf)
5896 {
5897- struct android_usb_function *f = dev_get_drvdata(dev);
5898- struct ncm_function_config *config = f->config;
5899- return snprintf(buf, PAGE_SIZE, "%04x\n", config->vendorID);
5900+ return snprintf(buf, PAGE_SIZE, "%s\n", rndis_transports);
5901 }
5902
5903-static ssize_t ncm_vendorID_store(struct device *dev,
5904+static ssize_t rndis_transports_store(struct device *dev,
5905+ struct device_attribute *attr, const char *buf, size_t size)
5906+{
5907+ strlcpy(rndis_transports, buf, sizeof(rndis_transports));
5908+ return size;
5909+}
5910+
5911+static DEVICE_ATTR(rndis_transports, S_IRUGO | S_IWUSR, rndis_transports_show,
5912+ rndis_transports_store);
5913+
5914+static ssize_t rndis_rx_trigger_store(struct device *dev,
5915 struct device_attribute *attr, const char *buf, size_t size)
5916 {
5917- struct android_usb_function *f = dev_get_drvdata(dev);
5918- struct ncm_function_config *config = f->config;
5919 int value;
5920
5921- if (sscanf(buf, "%04x", &value) == 1) {
5922- config->vendorID = value;
5923+ if (sscanf(buf, "%d", &value) == 1) {
5924+ rndis_rx_trigger();
5925 return size;
5926 }
5927 return -EINVAL;
5928 }
5929
5930-static DEVICE_ATTR(vendorID_ncm, S_IRUGO | S_IWUSR, ncm_vendorID_show,
5931- ncm_vendorID_store);
5932+static DEVICE_ATTR(rx_trigger, S_IWUSR, NULL,
5933+ rndis_rx_trigger_store);
5934
5935-static ssize_t ncm_ntb_out_size_show(struct device *dev,
5936+static ssize_t rndis_pkt_alignment_factor_show(struct device *dev,
5937 struct device_attribute *attr, char *buf)
5938 {
5939 struct android_usb_function *f = dev_get_drvdata(dev);
5940- struct ncm_function_config *config = f->config;
5941- return snprintf(buf, PAGE_SIZE, "%d\n", config->ntb_out_size);
5942+ struct rndis_function_config *config = f->config;
5943+
5944+ return snprintf(buf, PAGE_SIZE, "%d\n", config->pkt_alignment_factor);
5945 }
5946
5947-static ssize_t ncm_ntb_out_size_store(struct device *dev,
5948+static ssize_t rndis_pkt_alignment_factor_store(struct device *dev,
5949 struct device_attribute *attr, const char *buf, size_t size)
5950 {
5951 struct android_usb_function *f = dev_get_drvdata(dev);
5952- struct ncm_function_config *config = f->config;
5953+ struct rndis_function_config *config = f->config;
5954 int value;
5955
5956 if (sscanf(buf, "%d", &value) == 1) {
5957- config->ntb_out_size = value;
5958- pr_info("ntb_out_size = %d bytes", config->ntb_out_size);
5959-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
5960- ncm_ntb_out_size(config->ntb_out_size);
5961-#endif
5962+ config->pkt_alignment_factor = value;
5963 return size;
5964 }
5965+
5966 return -EINVAL;
5967 }
5968
5969-static DEVICE_ATTR(ntb_out_size_ncm, S_IRUGO | S_IWUSR, ncm_ntb_out_size_show,
5970- ncm_ntb_out_size_store);
5971+static DEVICE_ATTR(pkt_alignment_factor, S_IRUGO | S_IWUSR,
5972+ rndis_pkt_alignment_factor_show,
5973+ rndis_pkt_alignment_factor_store);
5974
5975-static struct device_attribute *ncm_function_attributes[] = {
5976- &dev_attr_manufacturer_ncm,
5977- &dev_attr_ethaddr_ncm,
5978- &dev_attr_vendorID_ncm,
5979- &dev_attr_ntb_out_size_ncm,
5980+static struct device_attribute *rndis_function_attributes[] = {
5981+ &dev_attr_manufacturer,
5982+ &dev_attr_wceis,
5983+ &dev_attr_ethaddr,
5984+ &dev_attr_vendorID,
5985+ &dev_attr_max_pkt_per_xfer,
5986+ &dev_attr_rndis_transports,
5987+ &dev_attr_rx_trigger,
5988+ &dev_attr_pkt_alignment_factor,
5989 NULL
5990 };
5991
5992-static struct android_usb_function ncm_function = {
5993- .name = "ncm",
5994- .init = ncm_function_init,
5995- .cleanup = ncm_function_cleanup,
5996- .bind_config = ncm_function_bind_config,
5997- .unbind_config = ncm_function_unbind_config,
5998- .attributes = ncm_function_attributes,
5999+static struct android_usb_function rndis_function = {
6000+ .name = "rndis",
6001+ .init = rndis_function_init,
6002+ .cleanup = rndis_function_cleanup,
6003+ .bind_config = rndis_function_bind_config,
6004+ .unbind_config = rndis_function_unbind_config,
6005+ .attributes = rndis_function_attributes,
6006+};
6007+
6008+static struct android_usb_function rndis_qc_function = {
6009+ .name = "rndis_qc",
6010+ .init = rndis_qc_function_init,
6011+ .cleanup = rndis_qc_function_cleanup,
6012+ .bind_config = rndis_qc_function_bind_config,
6013+ .unbind_config = rndis_qc_function_unbind_config,
6014+ .attributes = rndis_function_attributes,
6015+};
6016+
6017+static int ecm_function_bind_config(struct android_usb_function *f,
6018+ struct usb_configuration *c)
6019+{
6020+ int ret;
6021+ struct eth_dev *dev;
6022+ struct ecm_function_config *ecm = f->config;
6023+
6024+ if (!ecm) {
6025+ pr_err("%s: ecm_pdata\n", __func__);
6026+ return -EINVAL;
6027+ }
6028+
6029+ pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
6030+ ecm->ethaddr[0], ecm->ethaddr[1], ecm->ethaddr[2],
6031+ ecm->ethaddr[3], ecm->ethaddr[4], ecm->ethaddr[5]);
6032+
6033+ dev = gether_setup_name(c->cdev->gadget, ecm->ethaddr, "ecm");
6034+ if (IS_ERR(dev)) {
6035+ ret = PTR_ERR(dev);
6036+ pr_err("%s: gether_setup failed\n", __func__);
6037+ return ret;
6038+ }
6039+ ecm->dev = dev;
6040+
6041+ ret = ecm_bind_config(c, ecm->ethaddr, dev);
6042+ if (ret) {
6043+ pr_err("%s: ecm_bind_config failed\n", __func__);
6044+ gether_cleanup(dev);
6045+ }
6046+ return ret;
6047+}
6048+
6049+static void ecm_function_unbind_config(struct android_usb_function *f,
6050+ struct usb_configuration *c)
6051+{
6052+ struct ecm_function_config *ecm = f->config;
6053+ gether_cleanup(ecm->dev);
6054+}
6055+
6056+static struct android_usb_function ecm_function = {
6057+ .name = "ecm",
6058+ .init = ecm_function_init,
6059+ .cleanup = ecm_function_cleanup,
6060+ .bind_config = ecm_function_bind_config,
6061+ .unbind_config = ecm_function_unbind_config,
6062+ .attributes = ecm_function_attributes,
6063 };
6064
6065+#define MAX_LUN_STR_LEN 25
6066+static char lun_info[MAX_LUN_STR_LEN] = {'\0'};
6067 struct mass_storage_function_config {
6068 struct fsg_config fsg;
6069 struct fsg_common *common;
6070 };
6071
6072+#define MAX_LUN_NAME 8
6073 static int mass_storage_function_init(struct android_usb_function *f,
6074 struct usb_composite_dev *cdev)
6075 {
6076+ struct android_dev *dev = cdev_to_android_dev(cdev);
6077 struct mass_storage_function_config *config;
6078 struct fsg_common *common;
6079 int err;
6080-
6081-#ifdef CONFIG_USB_MULTI_DISK_SUPPORT
6082- int i, clear;
6083-#endif
6084+ int i, n;
6085+ char name[FSG_MAX_LUNS][MAX_LUN_NAME];
6086+ u8 uicc_nluns = dev->pdata ? dev->pdata->uicc_nluns : 0;
6087
6088 config = kzalloc(sizeof(struct mass_storage_function_config),
6089- GFP_KERNEL);
6090- if (!config)
6091+ GFP_KERNEL);
6092+ if (!config) {
6093+ pr_err("Memory allocation failed.\n");
6094 return -ENOMEM;
6095+ }
6096
6097-#ifdef CONFIG_USB_MULTI_DISK_SUPPORT
6098- config->fsg.nluns = CONFIG_USB_MASS_STORAGE_LUN_NUM;
6099- for (i = 0; i < config->fsg.nluns; i++)
6100- config->fsg.luns[i].removable = 1;
6101-#else
6102 config->fsg.nluns = 1;
6103+ snprintf(name[0], MAX_LUN_NAME, "lun");
6104 config->fsg.luns[0].removable = 1;
6105-#endif
6106+
6107+ if (dev->pdata && dev->pdata->cdrom) {
6108+ config->fsg.luns[config->fsg.nluns].cdrom = 1;
6109+ config->fsg.luns[config->fsg.nluns].ro = 1;
6110+ config->fsg.luns[config->fsg.nluns].removable = 0;
6111+ snprintf(name[config->fsg.nluns], MAX_LUN_NAME, "rom");
6112+ config->fsg.nluns++;
6113+ }
6114+
6115+ if (uicc_nluns > FSG_MAX_LUNS - config->fsg.nluns) {
6116+ uicc_nluns = FSG_MAX_LUNS - config->fsg.nluns;
6117+ pr_debug("limiting uicc luns to %d\n", uicc_nluns);
6118+ }
6119+
6120+ for (i = 0; i < uicc_nluns; i++) {
6121+ n = config->fsg.nluns;
6122+ snprintf(name[n], MAX_LUN_NAME, "uicc%d", i);
6123+ config->fsg.luns[n].removable = 1;
6124+ config->fsg.nluns++;
6125+ }
6126
6127 common = fsg_common_init(NULL, cdev, &config->fsg);
6128 if (IS_ERR(common)) {
6129@@ -1107,42 +2447,63 @@ static int mass_storage_function_init(struct android_usb_function *f,
6130 return PTR_ERR(common);
6131 }
6132
6133-#ifdef CONFIG_USB_MULTI_DISK_SUPPORT
6134 for (i = 0; i < config->fsg.nluns; i++) {
6135- char lun_name[8];
6136- sprintf(lun_name, "lun%d", i);
6137 err = sysfs_create_link(&f->dev->kobj,
6138- &common->luns[i].dev.kobj,
6139- lun_name);
6140- if (err) {
6141- pr_err("create lun %d failed!\n", i);
6142- break;
6143- }
6144+ &common->luns[i].dev.kobj,
6145+ name[i]);
6146+ if (err)
6147+ goto error;
6148 }
6149
6150- if (err) {
6151- for (clear = i-1; clear >= 0; clear--) {
6152- char lun_name[8];
6153- sprintf(lun_name, "lun%d", clear);
6154- sysfs_remove_link(&f->dev->kobj, lun_name);
6155- }
6156- kfree(config);
6157- return err;
6158+ config->common = common;
6159+ f->config = config;
6160+ return 0;
6161+error:
6162+ for (; i > 0; i--)
6163+ sysfs_remove_link(&f->dev->kobj, name[i-1]);
6164+
6165+ fsg_common_release(&common->ref);
6166+ kfree(config);
6167+ return err;
6168+}
6169+
6170+static int mass_storage_lun_init(struct android_usb_function *f,
6171+ char *lun_info)
6172+{
6173+ struct mass_storage_function_config *config = f->config;
6174+ bool inc_lun = true;
6175+ int i = config->fsg.nluns, index, length;
6176+ static int number_of_luns;
6177+
6178+ length = strlen(lun_info);
6179+ if (!length) {
6180+ pr_err("LUN_INFO is null.\n");
6181+ return -EINVAL;
6182 }
6183-#else
6184
6185- err = sysfs_create_link(&f->dev->kobj,
6186- &common->luns[0].dev.kobj,
6187- "lun");
6188- if (err) {
6189- kfree(config);
6190- return err;
6191+ index = i + number_of_luns;
6192+ if (index >= FSG_MAX_LUNS) {
6193+ pr_err("Number of LUNs exceed the limit.\n");
6194+ return -EINVAL;
6195 }
6196-#endif
6197
6198- config->common = common;
6199- f->config = config;
6200- return 0;
6201+ if (!strcmp(lun_info, "disk")) {
6202+ config->fsg.luns[index].removable = 1;
6203+ } else if (!strcmp(lun_info, "rom")) {
6204+ config->fsg.luns[index].cdrom = 1;
6205+ config->fsg.luns[index].removable = 0;
6206+ config->fsg.luns[index].ro = 1;
6207+ } else {
6208+ pr_err("Invalid LUN info.\n");
6209+ inc_lun = false;
6210+ return -EINVAL;
6211+ }
6212+
6213+ if (inc_lun)
6214+ number_of_luns++;
6215+
6216+ pr_debug("number_of_luns:%d\n", number_of_luns);
6217+ return number_of_luns;
6218 }
6219
6220 static void mass_storage_function_cleanup(struct android_usb_function *f)
6221@@ -1151,11 +2512,72 @@ static void mass_storage_function_cleanup(struct android_usb_function *f)
6222 f->config = NULL;
6223 }
6224
6225+static void mass_storage_function_enable(struct android_usb_function *f)
6226+{
6227+ struct usb_composite_dev *cdev = f->android_dev->cdev;
6228+ struct mass_storage_function_config *config = f->config;
6229+ struct fsg_common *common = config->common;
6230+ char *lun_type;
6231+ int i, err, prev_nluns;
6232+ char buf[MAX_LUN_STR_LEN], *b;
6233+ int number_of_luns = 0;
6234+ char buf1[5];
6235+ char *lun_name = buf1;
6236+ static int msc_initialized;
6237+
6238+ if (msc_initialized)
6239+ return;
6240+
6241+ prev_nluns = config->fsg.nluns;
6242+
6243+ if (lun_info[0] != '\0') {
6244+ strlcpy(buf, lun_info, sizeof(buf));
6245+ b = strim(buf);
6246+
6247+ while (b) {
6248+ lun_type = strsep(&b, ",");
6249+ if (lun_type)
6250+ number_of_luns =
6251+ mass_storage_lun_init(f, lun_type);
6252+ if (number_of_luns <= 0)
6253+ return;
6254+ }
6255+ } else {
6256+ pr_debug("No extra msc lun required.\n");
6257+ return;
6258+ }
6259+
6260+ err = fsg_add_lun(common, cdev, &config->fsg, number_of_luns);
6261+ if (err) {
6262+ pr_err("Failed adding LUN.\n");
6263+ return;
6264+ }
6265+
6266+ pr_debug("fsg.nluns:%d\n", config->fsg.nluns);
6267+ for (i = prev_nluns; i < config->fsg.nluns; i++) {
6268+ snprintf(lun_name, sizeof(buf), "lun%d", (i-prev_nluns));
6269+ pr_debug("sysfs: LUN name:%s\n", lun_name);
6270+ err = sysfs_create_link(&f->dev->kobj,
6271+ &common->luns[i].dev.kobj, lun_name);
6272+ if (err)
6273+ pr_err("sysfs file creation failed: lun%d err:%d\n",
6274+ (i-prev_nluns), err);
6275+ }
6276+
6277+ msc_initialized = 1;
6278+}
6279+
6280 static int mass_storage_function_bind_config(struct android_usb_function *f,
6281 struct usb_configuration *c)
6282 {
6283 struct mass_storage_function_config *config = f->config;
6284- return fsg_bind_config(c->cdev, c, config->common);
6285+ int ret;
6286+
6287+ ret = fsg_bind_config(c->cdev, c, config->common);
6288+ if (ret)
6289+ pr_err("fsg_bind_config failed. ret:%x\n", ret);
6290+
6291+ return ret;
6292 }
6293
6294 static ssize_t mass_storage_inquiry_show(struct device *dev,
6295@@ -1163,7 +2585,7 @@ static ssize_t mass_storage_inquiry_show(struct device *dev,
6296 {
6297 struct android_usb_function *f = dev_get_drvdata(dev);
6298 struct mass_storage_function_config *config = f->config;
6299- return sprintf(buf, "%s\n", config->common->inquiry_string);
6300+ return snprintf(buf, PAGE_SIZE, "%s\n", config->common->inquiry_string);
6301 }
6302
6303 static ssize_t mass_storage_inquiry_store(struct device *dev,
6304@@ -1173,7 +2595,7 @@ static ssize_t mass_storage_inquiry_store(struct device *dev,
6305 struct mass_storage_function_config *config = f->config;
6306 if (size >= sizeof(config->common->inquiry_string))
6307 return -EINVAL;
6308- if (sscanf(buf, "%s", config->common->inquiry_string) != 1)
6309+ if (sscanf(buf, "%28s", config->common->inquiry_string) != 1)
6310 return -EINVAL;
6311 return size;
6312 }
6313@@ -1182,8 +2604,27 @@ static DEVICE_ATTR(inquiry_string, S_IRUGO | S_IWUSR,
6314 mass_storage_inquiry_show,
6315 mass_storage_inquiry_store);
6316
6317+static ssize_t mass_storage_lun_info_show(struct device *dev,
6318+ struct device_attribute *attr, char *buf)
6319+{
6320+
6321+ return snprintf(buf, PAGE_SIZE, "%s\n", lun_info);
6322+}
6323+
6324+static ssize_t mass_storage_lun_info_store(struct device *dev,
6325+ struct device_attribute *attr, const char *buf, size_t size)
6326+{
6327+ strlcpy(lun_info, buf, sizeof(lun_info));
6328+ return size;
6329+}
6330+
6331+static DEVICE_ATTR(luns, S_IRUGO | S_IWUSR,
6332+ mass_storage_lun_info_show,
6333+ mass_storage_lun_info_store);
6334+
6335 static struct device_attribute *mass_storage_function_attributes[] = {
6336 &dev_attr_inquiry_string,
6337+ &dev_attr_luns,
6338 NULL
6339 };
6340
6341@@ -1193,6 +2634,7 @@ static struct android_usb_function mass_storage_function = {
6342 .cleanup = mass_storage_function_cleanup,
6343 .bind_config = mass_storage_function_bind_config,
6344 .attributes = mass_storage_function_attributes,
6345+ .enable = mass_storage_function_enable,
6346 };
6347
6348
6349@@ -1228,8 +2670,7 @@ static struct android_usb_function accessory_function = {
6350 .ctrlrequest = accessory_function_ctrlrequest,
6351 };
6352
6353-
6354-#ifdef CONFIG_SOUND
6355+#ifdef CONFIG_SND_PCM
6356 static int audio_source_function_init(struct android_usb_function *f,
6357 struct usb_composite_dev *cdev)
6358 {
6359@@ -1273,12 +2714,10 @@ static ssize_t audio_source_pcm_show(struct device *dev,
6360 struct audio_source_config *config = f->config;
6361
6362 /* print PCM card and device numbers */
6363- return snprintf(buf, PAGE_SIZE, "%d %d\n", config->card,
6364- config->device);
6365+ return sprintf(buf, "%d %d\n", config->card, config->device);
6366 }
6367
6368-
6369-static DEVICE_ATTR(pcm, S_IRUGO /*| S_IWUSR*/, audio_source_pcm_show, NULL);
6370+static DEVICE_ATTR(pcm, S_IRUGO, audio_source_pcm_show, NULL);
6371
6372 static struct device_attribute *audio_source_function_attributes[] = {
6373 &dev_attr_pcm,
6374@@ -1295,133 +2734,135 @@ static struct android_usb_function audio_source_function = {
6375 };
6376 #endif
6377
6378-struct hid_function_config {
6379- struct hidg_func_descriptor *fdesc;
6380- int index;
6381-};
6382-
6383-/* hid descriptor for a keyboard */
6384-static struct hidg_func_descriptor hid_keyboard_fdesc = {
6385- .subclass = 0, /* No subclass */
6386- .protocol = 1, /* Keyboard */
6387- .report_length = 8,
6388- .report_desc_length = 63,
6389- .report_desc = {
6390- 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
6391- 0x09, 0x06, /* USAGE (Keyboard) */
6392- 0xa1, 0x01, /* COLLECTION (Application) */
6393- 0x05, 0x07, /* USAGE_PAGE (Keyboard) */
6394- 0x19, 0xe0, /* USAGE_MINIMUM (Keyboard LeftControl) */
6395- 0x29, 0xe7, /* USAGE_MAXIMUM (Keyboard Right GUI) */
6396- 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
6397- 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */
6398- 0x75, 0x01, /* REPORT_SIZE (1) */
6399- 0x95, 0x08, /* REPORT_COUNT (8) */
6400- 0x81, 0x02, /* INPUT (Data,Var,Abs) */
6401- 0x95, 0x01, /* REPORT_COUNT (1) */
6402- 0x75, 0x08, /* REPORT_SIZE (8) */
6403- 0x81, 0x03, /* INPUT (Cnst,Var,Abs) */
6404- 0x95, 0x05, /* REPORT_COUNT (5) */
6405- 0x75, 0x01, /* REPORT_SIZE (1) */
6406- 0x05, 0x08, /* USAGE_PAGE (LEDs) */
6407- 0x19, 0x01, /* USAGE_MINIMUM (Num Lock) */
6408- 0x29, 0x05, /* USAGE_MAXIMUM (Kana) */
6409- 0x91, 0x02, /* OUTPUT (Data,Var,Abs) */
6410- 0x95, 0x01, /* REPORT_COUNT (1) */
6411- 0x75, 0x03, /* REPORT_SIZE (3) */
6412- 0x91, 0x03, /* OUTPUT (Cnst,Var,Abs) */
6413- 0x95, 0x06, /* REPORT_COUNT (6) */
6414- 0x75, 0x08, /* REPORT_SIZE (8) */
6415- 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
6416- 0x25, 0x65, /* LOGICAL_MAXIMUM (101) */
6417- 0x05, 0x07, /* USAGE_PAGE (Keyboard) */
6418- 0x19, 0x00, /* USAGE_MINIMUM (Reserved) */
6419- 0x29, 0x65, /* USAGE_MAXIMUM (Keyboard Application) */
6420- 0x81, 0x00, /* INPUT (Data,Ary,Abs) */
6421- 0xc0 /* END_COLLECTION */
6422- }
6423-};
6424-
6425-static int hid_function_init(struct android_usb_function *f,
6426- struct usb_composite_dev *cdev)
6427+static int android_uasp_connect_cb(bool connect)
6428 {
6429- struct hid_function_config *config;
6430- int status = 0;
6431-
6432- config = kzalloc(sizeof(struct hid_function_config), GFP_KERNEL);
6433- if (!config)
6434- return -ENOMEM;
6435- config->fdesc = &hid_keyboard_fdesc;
6436- config->index = 0;
6437- f->config = config;
6438-
6439- /* set up HID */
6440- status = ghid_setup(cdev->gadget, 1);
6441- if (status < 0)
6442- return status;
6443+ /*
6444+ * TODO
6445+ * We may have to disable gadget till UASP configfs nodes
6446+ * are configured which includes mapping LUN with the
6447+ * backing file. It is a fundamental difference between
6448+ * f_mass_storage and f_tcp. That means UASP can not be
6449+ * in default composition.
6450+ *
6451+ * For now, assume that UASP configfs nodes are configured
6452+ * before enabling android gadget. Or cable should be
6453+ * reconnected after mapping the LUN.
6454+ *
6455+ * Also consider making UASP to respond to Host requests when
6456+ * Lun is not mapped.
6457+ */
6458+ pr_debug("UASP %s\n", connect ? "connect" : "disconnect");
6459
6460 return 0;
6461 }
6462
6463-static void hid_function_cleanup(struct android_usb_function *f)
6464+static int uasp_function_init(struct android_usb_function *f,
6465+ struct usb_composite_dev *cdev)
6466+{
6467+ return f_tcm_init(&android_uasp_connect_cb);
6468+}
6469+
6470+static void uasp_function_cleanup(struct android_usb_function *f)
6471 {
6472- ghid_cleanup();
6473- kfree(f->config);
6474+ f_tcm_exit();
6475 }
6476
6477-static int hid_function_bind_config(struct android_usb_function *f,
6478+static int uasp_function_bind_config(struct android_usb_function *f,
6479 struct usb_configuration *c)
6480 {
6481- struct hid_function_config *config = f->config;
6482-
6483- return hidg_bind_config(c, config->fdesc, config->index);
6484+ return tcm_bind_config(c);
6485 }
6486
6487-static struct android_usb_function hid_function = {
6488- .name = "hid",
6489- .init = hid_function_init,
6490- .cleanup = hid_function_cleanup,
6491- .bind_config = hid_function_bind_config,
6492+static struct android_usb_function uasp_function = {
6493+ .name = "uasp",
6494+ .init = uasp_function_init,
6495+ .cleanup = uasp_function_cleanup,
6496+ .bind_config = uasp_function_bind_config,
6497 };
6498
6499 static struct android_usb_function *supported_functions[] = {
6500 &ffs_function,
6501- &acm_function,
6502-#ifdef CONFIG_USB_GADGET_GG
6503- &gg_function,
6504+ &mbim_function,
6505+ &ecm_qc_function,
6506+#ifdef CONFIG_SND_PCM
6507+ &audio_function,
6508 #endif
6509+ &rmnet_smd_function,
6510+ &rmnet_function,
6511+ &gps_function,
6512+ &diag_function,
6513+ &qdss_function,
6514+ &serial_function,
6515+ &ccid_function,
6516+ &acm_function,
6517 &mtp_function,
6518 &ptp_function,
6519 &rndis_function,
6520+ &rndis_qc_function,
6521+ &ecm_function,
6522+ &ncm_function,
6523 &mass_storage_function,
6524 &accessory_function,
6525-#ifdef CONFIG_SOUND
6526+#ifdef CONFIG_SND_PCM
6527 &audio_source_function,
6528 #endif
6529- &ncm_function,
6530- &hid_function,
6531+ &uasp_function,
6532+ &charger_function,
6533 NULL
6534 };
6535
6536+static void android_cleanup_functions(struct android_usb_function **functions)
6537+{
6538+ struct android_usb_function *f;
6539+ struct device_attribute **attrs;
6540+ struct device_attribute *attr;
6541+
6542+ while (*functions) {
6543+ f = *functions++;
6544+
6545+ if (f->dev) {
6546+ device_destroy(android_class, f->dev->devt);
6547+ kfree(f->dev_name);
6548+ } else
6549+ continue;
6550+
6551+ if (f->cleanup)
6552+ f->cleanup(f);
6553+
6554+ attrs = f->attributes;
6555+ if (attrs) {
6556+ while ((attr = *attrs++))
6557+ device_remove_file(f->dev, attr);
6558+ }
6559+ }
6560+}
6561
6562 static int android_init_functions(struct android_usb_function **functions,
6563 struct usb_composite_dev *cdev)
6564 {
6565- struct android_dev *dev = _android_dev;
6566+ struct android_dev *dev = cdev_to_android_dev(cdev);
6567 struct android_usb_function *f;
6568 struct device_attribute **attrs;
6569 struct device_attribute *attr;
6570 int err = 0;
6571- int index = 0;
6572+ int index = 2; /* index 0 is for android0 device
6573+ * index 1 is for android1 device
6574+ */
6575
6576 for (; (f = *functions++); index++) {
6577 f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name);
6578+ f->android_dev = NULL;
6579+ if (!f->dev_name) {
6580+ err = -ENOMEM;
6581+ goto err_out;
6582+ }
6583 f->dev = device_create(android_class, dev->dev,
6584 MKDEV(0, index), f, f->dev_name);
6585 if (IS_ERR(f->dev)) {
6586 pr_err("%s: Failed to create dev %s", __func__,
6587 f->dev_name);
6588 err = PTR_ERR(f->dev);
6589+ f->dev = NULL;
6590 goto err_create;
6591 }
6592
6593@@ -1430,7 +2871,7 @@ static int android_init_functions(struct android_usb_function **functions,
6594 if (err) {
6595 pr_err("%s: Failed to init %s", __func__,
6596 f->name);
6597- goto err_out;
6598+ goto err_init;
6599 }
6600 }
6601
6602@@ -1441,47 +2882,51 @@ static int android_init_functions(struct android_usb_function **functions,
6603 }
6604 if (err) {
6605 pr_err("%s: Failed to create function %s attributes",
6606- __func__, f->name);
6607- goto err_out;
6608- }
6609- }
6610- return 0;
6611-
6612-err_out:
6613- device_destroy(android_class, f->dev->devt);
6614-err_create:
6615- kfree(f->dev_name);
6616- return err;
6617-}
6618-
6619-static void android_cleanup_functions(struct android_usb_function **functions)
6620-{
6621- struct android_usb_function *f;
6622-
6623- while (*functions) {
6624- f = *functions++;
6625-
6626- if (f->dev) {
6627- device_destroy(android_class, f->dev->devt);
6628- kfree(f->dev_name);
6629+ __func__, f->name);
6630+ goto err_attrs;
6631 }
6632-
6633- if (f->cleanup)
6634- f->cleanup(f);
6635 }
6636+ return 0;
6637+
6638+err_attrs:
6639+ for (attr = *(attrs -= 2); attrs != f->attributes; attr = *(attrs--))
6640+ device_remove_file(f->dev, attr);
6641+ if (f->cleanup)
6642+ f->cleanup(f);
6643+err_init:
6644+ device_destroy(android_class, f->dev->devt);
6645+err_create:
6646+ f->dev = NULL;
6647+ kfree(f->dev_name);
6648+err_out:
6649+ android_cleanup_functions(dev->functions);
6650+ return err;
6651 }
6652
6653 static int
6654 android_bind_enabled_functions(struct android_dev *dev,
6655 struct usb_configuration *c)
6656 {
6657- struct android_usb_function *f;
6658+ struct android_usb_function_holder *f_holder;
6659+ struct android_configuration *conf =
6660+ container_of(c, struct android_configuration, usb_config);
6661 int ret;
6662
6663- list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
6664- ret = f->bind_config(f, c);
6665+ list_for_each_entry(f_holder, &conf->enabled_functions, enabled_list) {
6666+ ret = f_holder->f->bind_config(f_holder->f, c);
6667 if (ret) {
6668- pr_err("%s: %s failed", __func__, f->name);
6669+ pr_err("%s: %s failed\n", __func__, f_holder->f->name);
6670+ while (!list_empty(&c->functions)) {
6671+ struct usb_function *f;
6672+
6673+ f = list_first_entry(&c->functions,
6674+ struct usb_function, list);
6675+ list_del(&f->list);
6676+ if (f->unbind)
6677+ f->unbind(c, f);
6678+ }
6679+ if (c->unbind)
6680+ c->unbind(c);
6681 return ret;
6682 }
6683 }
6684@@ -1492,23 +2937,65 @@ static void
6685 android_unbind_enabled_functions(struct android_dev *dev,
6686 struct usb_configuration *c)
6687 {
6688- struct android_usb_function *f;
6689+ struct android_usb_function_holder *f_holder;
6690+ struct android_configuration *conf =
6691+ container_of(c, struct android_configuration, usb_config);
6692
6693- list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
6694- if (f->unbind_config)
6695- f->unbind_config(f, c);
6696+ list_for_each_entry(f_holder, &conf->enabled_functions, enabled_list) {
6697+ if (f_holder->f->unbind_config)
6698+ f_holder->f->unbind_config(f_holder->f, c);
6699 }
6700 }
6701+static inline void check_streaming_func(struct usb_gadget *gadget,
6702+ struct android_usb_platform_data *pdata,
6703+ char *name)
6704+{
6705+ int i;
6706
6707-static int android_enable_function(struct android_dev *dev, char *name)
6708+ for (i = 0; i < pdata->streaming_func_count; i++) {
6709+ if (!strcmp(name, pdata->streaming_func[i])) {
6710+ pr_debug("set streaming_enabled to true\n");
6711+ gadget->streaming_enabled = true;
6712+ break;
6713+ }
6714+ }
6715+}
6716+static int android_enable_function(struct android_dev *dev,
6717+ struct android_configuration *conf,
6718+ char *name)
6719 {
6720 struct android_usb_function **functions = dev->functions;
6721 struct android_usb_function *f;
6722+ struct android_usb_function_holder *f_holder;
6723+ struct android_usb_platform_data *pdata = dev->pdata;
6724+ struct usb_gadget *gadget = dev->cdev->gadget;
6725+
6726 while ((f = *functions++)) {
6727 if (!strcmp(name, f->name)) {
6728- list_add_tail(&f->enabled_list,
6729- &dev->enabled_functions);
6730- return 0;
6731+ if (f->android_dev && f->android_dev != dev)
6732+ pr_err("%s is enabled in other device\n",
6733+ f->name);
6734+ else {
6735+ f_holder = kzalloc(sizeof(*f_holder),
6736+ GFP_KERNEL);
6737+ if (!f_holder) {
6738+ pr_err("Failed to alloc f_holder\n");
6739+ return -ENOMEM;
6740+ }
6741+
6742+ f->android_dev = dev;
6743+ f_holder->f = f;
6744+ list_add_tail(&f_holder->enabled_list,
6745+ &conf->enabled_functions);
6746+ pr_debug("func:%s is enabled.\n", f->name);
6747+ /*
6748+ * compare enable function with streaming func
6749+ * list and based on the same request streaming.
6750+ */
6751+ check_streaming_func(gadget, pdata, f->name);
6752+
6753+ return 0;
6754+ }
6755 }
6756 }
6757 return -EINVAL;
6758@@ -1517,17 +3004,68 @@ static int android_enable_function(struct android_dev *dev, char *name)
6759 /*-------------------------------------------------------------------------*/
6760 /* /sys/class/android_usb/android%d/ interface */
6761
6762+static ssize_t remote_wakeup_show(struct device *pdev,
6763+ struct device_attribute *attr, char *buf)
6764+{
6765+ struct android_dev *dev = dev_get_drvdata(pdev);
6766+ struct android_configuration *conf;
6767+
6768+ /*
6769+ * Show the wakeup attribute of the first configuration,
6770+ * since all configurations have the same wakeup attribute
6771+ */
6772+ if (dev->configs_num == 0)
6773+ return 0;
6774+ conf = list_entry(dev->configs.next,
6775+ struct android_configuration,
6776+ list_item);
6777+
6778+ return snprintf(buf, PAGE_SIZE, "%d\n",
6779+ !!(conf->usb_config.bmAttributes &
6780+ USB_CONFIG_ATT_WAKEUP));
6781+}
6782+
6783+static ssize_t remote_wakeup_store(struct device *pdev,
6784+ struct device_attribute *attr, const char *buff, size_t size)
6785+{
6786+ struct android_dev *dev = dev_get_drvdata(pdev);
6787+ struct android_configuration *conf;
6788+ int enable = 0;
6789+
6790+ sscanf(buff, "%d", &enable);
6791+
6792+ pr_debug("android_usb: %s remote wakeup\n",
6793+ enable ? "enabling" : "disabling");
6794+
6795+ list_for_each_entry(conf, &dev->configs, list_item)
6796+ if (enable)
6797+ conf->usb_config.bmAttributes |=
6798+ USB_CONFIG_ATT_WAKEUP;
6799+ else
6800+ conf->usb_config.bmAttributes &=
6801+ ~USB_CONFIG_ATT_WAKEUP;
6802+
6803+ return size;
6804+}
6805+
6806 static ssize_t
6807 functions_show(struct device *pdev, struct device_attribute *attr, char *buf)
6808 {
6809 struct android_dev *dev = dev_get_drvdata(pdev);
6810- struct android_usb_function *f;
6811+ struct android_configuration *conf;
6812+ struct android_usb_function_holder *f_holder;
6813 char *buff = buf;
6814
6815 mutex_lock(&dev->mutex);
6816
6817- list_for_each_entry(f, &dev->enabled_functions, enabled_list)
6818- buff += sprintf(buff, "%s,", f->name);
6819+ list_for_each_entry(conf, &dev->configs, list_item) {
6820+ if (buff != buf)
6821+ *(buff-1) = ':';
6822+ list_for_each_entry(f_holder, &conf->enabled_functions,
6823+ enabled_list)
6824+ buff += snprintf(buff, PAGE_SIZE, "%s,",
6825+ f_holder->f->name);
6826+ }
6827
6828 mutex_unlock(&dev->mutex);
6829
6830@@ -1541,6 +3079,10 @@ functions_store(struct device *pdev, struct device_attribute *attr,
6831 const char *buff, size_t size)
6832 {
6833 struct android_dev *dev = dev_get_drvdata(pdev);
6834+ struct list_head *curr_conf = &dev->configs;
6835+ struct android_configuration *conf;
6836+ char *conf_str;
6837+ struct android_usb_function_holder *f_holder;
6838 char *name;
6839 char buf[256], *b;
6840 char aliases[256], *a;
6841@@ -1555,44 +3097,79 @@ functions_store(struct device *pdev, struct device_attribute *attr,
6842 return -EBUSY;
6843 }
6844
6845- INIT_LIST_HEAD(&dev->enabled_functions);
6846+ /* Clear previous enabled list */
6847+ list_for_each_entry(conf, &dev->configs, list_item) {
6848+ while (conf->enabled_functions.next !=
6849+ &conf->enabled_functions) {
6850+ f_holder = list_entry(conf->enabled_functions.next,
6851+ typeof(*f_holder),
6852+ enabled_list);
6853+ f_holder->f->android_dev = NULL;
6854+ list_del(&f_holder->enabled_list);
6855+ kfree(f_holder);
6856+ }
6857+ INIT_LIST_HEAD(&conf->enabled_functions);
6858+ }
6859
6860 strlcpy(buf, buff, sizeof(buf));
6861 b = strim(buf);
6862
6863 while (b) {
6864- name = strsep(&b, ",");
6865- if (!name)
6866+ conf_str = strsep(&b, ":");
6867+ if (!conf_str)
6868 continue;
6869
6870- is_ffs = 0;
6871- strlcpy(aliases, dev->ffs_aliases, sizeof(aliases));
6872- a = aliases;
6873-
6874- while (a) {
6875- char *alias = strsep(&a, ",");
6876- if (alias && !strcmp(name, alias)) {
6877- is_ffs = 1;
6878- break;
6879+ /* If the next not equal to the head, take it */
6880+ if (curr_conf->next != &dev->configs)
6881+ conf = list_entry(curr_conf->next,
6882+ struct android_configuration,
6883+ list_item);
6884+ else
6885+ conf = alloc_android_config(dev);
6886+
6887+ curr_conf = curr_conf->next;
6888+ while (conf_str) {
6889+ name = strsep(&conf_str, ",");
6890+ is_ffs = 0;
6891+ strlcpy(aliases, dev->ffs_aliases, sizeof(aliases));
6892+ a = aliases;
6893+
6894+ while (a) {
6895+ char *alias = strsep(&a, ",");
6896+ if (alias && !strcmp(name, alias)) {
6897+ is_ffs = 1;
6898+ break;
6899+ }
6900 }
6901- }
6902
6903- if (is_ffs) {
6904- if (ffs_enabled)
6905+ if (is_ffs) {
6906+ if (ffs_enabled)
6907+ continue;
6908+ err = android_enable_function(dev, conf, "ffs");
6909+ if (err)
6910+ pr_err("android_usb: Cannot enable ffs (%d)",
6911+ err);
6912+ else
6913+ ffs_enabled = 1;
6914 continue;
6915- err = android_enable_function(dev, "ffs");
6916+ }
6917+
6918+ if (!strcmp(name, "rndis") &&
6919+ !strcmp(strim(rndis_transports), "BAM2BAM_IPA"))
6920+ name = "rndis_qc";
6921+
6922+ err = android_enable_function(dev, conf, name);
6923 if (err)
6924- pr_err("android_usb: Cannot enable ffs (%d)",
6925- err);
6926- else
6927- ffs_enabled = 1;
6928- continue;
6929+ pr_err("android_usb: Cannot enable '%s' (%d)",
6930+ name, err);
6931 }
6932+ }
6933
6934- err = android_enable_function(dev, name);
6935- if (err)
6936- pr_err("android_usb: Cannot enable '%s' (%d)",
6937- name, err);
6938+ /* Free uneeded configurations if exists */
6939+ while (curr_conf->next != &dev->configs) {
6940+ conf = list_entry(curr_conf->next,
6941+ struct android_configuration, list_item);
6942+ free_android_config(dev, conf);
6943 }
6944
6945 mutex_unlock(&dev->mutex);
6946@@ -1604,7 +3181,8 @@ static ssize_t enable_show(struct device *pdev, struct device_attribute *attr,
6947 char *buf)
6948 {
6949 struct android_dev *dev = dev_get_drvdata(pdev);
6950- return sprintf(buf, "%d\n", dev->enabled);
6951+
6952+ return snprintf(buf, PAGE_SIZE, "%d\n", dev->enabled);
6953 }
6954
6955 static ssize_t enable_store(struct device *pdev, struct device_attribute *attr,
6956@@ -1612,9 +3190,12 @@ static ssize_t enable_store(struct device *pdev, struct device_attribute *attr,
6957 {
6958 struct android_dev *dev = dev_get_drvdata(pdev);
6959 struct usb_composite_dev *cdev = dev->cdev;
6960- struct android_usb_function *f;
6961+ struct android_usb_function_holder *f_holder;
6962+ struct android_configuration *conf;
6963 int enabled = 0;
6964-
6965+ bool audio_enabled = false;
6966+ static DEFINE_RATELIMIT_STATE(rl, 10*HZ, 1);
6967+ int err = 0;
6968
6969 if (!cdev)
6970 return -ENODEV;
6971@@ -1633,28 +3214,78 @@ static ssize_t enable_store(struct device *pdev, struct device_attribute *attr,
6972 cdev->desc.bDeviceClass = device_desc.bDeviceClass;
6973 cdev->desc.bDeviceSubClass = device_desc.bDeviceSubClass;
6974 cdev->desc.bDeviceProtocol = device_desc.bDeviceProtocol;
6975- list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
6976- if (f->enable)
6977- f->enable(f);
6978+
6979+ /* Audio dock accessory is unable to enumerate device if
6980+ * pull-up is enabled immediately. The enumeration is
6981+ * reliable with 100 msec delay.
6982+ */
6983+ list_for_each_entry(conf, &dev->configs, list_item)
6984+ list_for_each_entry(f_holder, &conf->enabled_functions,
6985+ enabled_list) {
6986+ if (f_holder->f->enable)
6987+ f_holder->f->enable(f_holder->f);
6988+ if (!strncmp(f_holder->f->name,
6989+ "audio_source", 12))
6990+ audio_enabled = true;
6991+ }
6992+ if (audio_enabled)
6993+ msleep(100);
6994+ err = android_enable(dev);
6995+ if (err < 0) {
6996+ pr_err("%s: android_enable failed\n", __func__);
6997+ dev->connected = 0;
6998+ dev->enabled = false;
6999+ mutex_unlock(&dev->mutex);
7000+ return size;
7001 }
7002- android_enable(dev);
7003 dev->enabled = true;
7004 } else if (!enabled && dev->enabled) {
7005 android_disable(dev);
7006- list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
7007- if (f->disable)
7008- f->disable(f);
7009- }
7010+ list_for_each_entry(conf, &dev->configs, list_item)
7011+ list_for_each_entry(f_holder, &conf->enabled_functions,
7012+ enabled_list) {
7013+ if (f_holder->f->disable)
7014+ f_holder->f->disable(f_holder->f);
7015+ }
7016 dev->enabled = false;
7017- } else {
7018+ } else if (__ratelimit(&rl)) {
7019 pr_err("android_usb: already %s\n",
7020 dev->enabled ? "enabled" : "disabled");
7021 }
7022
7023 mutex_unlock(&dev->mutex);
7024+
7025+ return size;
7026+}
7027+
7028+static ssize_t pm_qos_show(struct device *pdev,
7029+ struct device_attribute *attr, char *buf)
7030+{
7031+ struct android_dev *dev = dev_get_drvdata(pdev);
7032+
7033+ return snprintf(buf, PAGE_SIZE, "%s\n", dev->pm_qos);
7034+}
7035+
7036+static ssize_t pm_qos_store(struct device *pdev,
7037+ struct device_attribute *attr,
7038+ const char *buff, size_t size)
7039+{
7040+ struct android_dev *dev = dev_get_drvdata(pdev);
7041+
7042+ strlcpy(dev->pm_qos, buff, sizeof(dev->pm_qos));
7043+
7044 return size;
7045 }
7046
7047+static ssize_t pm_qos_state_show(struct device *pdev,
7048+ struct device_attribute *attr, char *buf)
7049+{
7050+ struct android_dev *dev = dev_get_drvdata(pdev);
7051+
7052+ return snprintf(buf, PAGE_SIZE, "%s\n",
7053+ pm_qos_to_string(dev->curr_pm_qos_state));
7054+}
7055+
7056 static ssize_t state_show(struct device *pdev, struct device_attribute *attr,
7057 char *buf)
7058 {
7059@@ -1673,15 +3304,41 @@ static ssize_t state_show(struct device *pdev, struct device_attribute *attr,
7060 state = "CONNECTED";
7061 spin_unlock_irqrestore(&cdev->lock, flags);
7062 out:
7063- return sprintf(buf, "%s\n", state);
7064+ return snprintf(buf, PAGE_SIZE, "%s\n", state);
7065 }
7066
7067+#define ANDROID_DEV_ATTR(field, format_string) \
7068+static ssize_t \
7069+field ## _show(struct device *pdev, struct device_attribute *attr, \
7070+ char *buf) \
7071+{ \
7072+ struct android_dev *dev = dev_get_drvdata(pdev); \
7073+ \
7074+ return snprintf(buf, PAGE_SIZE, \
7075+ format_string, dev->field); \
7076+} \
7077+static ssize_t \
7078+field ## _store(struct device *pdev, struct device_attribute *attr, \
7079+ const char *buf, size_t size) \
7080+{ \
7081+ unsigned value; \
7082+ struct android_dev *dev = dev_get_drvdata(pdev); \
7083+ \
7084+ if (sscanf(buf, format_string, &value) == 1) { \
7085+ dev->field = value; \
7086+ return size; \
7087+ } \
7088+ return -EINVAL; \
7089+} \
7090+static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
7091+
7092 #define DESCRIPTOR_ATTR(field, format_string) \
7093 static ssize_t \
7094 field ## _show(struct device *dev, struct device_attribute *attr, \
7095 char *buf) \
7096 { \
7097- return sprintf(buf, format_string, device_desc.field); \
7098+ return snprintf(buf, PAGE_SIZE, \
7099+ format_string, device_desc.field); \
7100 } \
7101 static ssize_t \
7102 field ## _store(struct device *dev, struct device_attribute *attr, \
7103@@ -1701,7 +3358,7 @@ static ssize_t \
7104 field ## _show(struct device *dev, struct device_attribute *attr, \
7105 char *buf) \
7106 { \
7107- return sprintf(buf, "%s", buffer); \
7108+ return snprintf(buf, PAGE_SIZE, "%s", buffer); \
7109 } \
7110 static ssize_t \
7111 field ## _store(struct device *dev, struct device_attribute *attr, \
7112@@ -1709,7 +3366,9 @@ field ## _store(struct device *dev, struct device_attribute *attr, \
7113 { \
7114 if (size >= sizeof(buffer)) \
7115 return -EINVAL; \
7116- return strlcpy(buffer, buf, sizeof(buffer)); \
7117+ strlcpy(buffer, buf, sizeof(buffer)); \
7118+ strim(buffer); \
7119+ return size; \
7120 } \
7121 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
7122
7123@@ -1717,19 +3376,9 @@ static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
7124 DESCRIPTOR_ATTR(idVendor, "%04x\n")
7125 DESCRIPTOR_ATTR(idProduct, "%04x\n")
7126 DESCRIPTOR_ATTR(bcdDevice, "%04x\n")
7127-#if defined CONFIG_MACH_RHEA_SS \
7128-|| defined CONFIG_MACH_RHEA_SS_ZANIN \
7129-|| defined CONFIG_MACH_RHEA_SS_LUCAS \
7130-|| defined CONFIG_MACH_RHEA_SS_AMAZING \
7131-|| defined CONFIG_MACH_RHEA_SS_IVORY
7132-DESCRIPTOR_ATTR(bDeviceClass, "%02x\n")
7133-DESCRIPTOR_ATTR(bDeviceSubClass, "%02x\n")
7134-DESCRIPTOR_ATTR(bDeviceProtocol, "%02x\n")
7135-#else
7136 DESCRIPTOR_ATTR(bDeviceClass, "%d\n")
7137 DESCRIPTOR_ATTR(bDeviceSubClass, "%d\n")
7138 DESCRIPTOR_ATTR(bDeviceProtocol, "%d\n")
7139-#endif
7140 DESCRIPTOR_STRING_ATTR(iManufacturer, manufacturer_string)
7141 DESCRIPTOR_STRING_ATTR(iProduct, product_string)
7142 DESCRIPTOR_STRING_ATTR(iSerial, serial_string)
7143@@ -1737,7 +3386,18 @@ DESCRIPTOR_STRING_ATTR(iSerial, serial_string)
7144 static DEVICE_ATTR(functions, S_IRUGO | S_IWUSR, functions_show,
7145 functions_store);
7146 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store);
7147+
7148+static DEVICE_ATTR(pm_qos, S_IRUGO | S_IWUSR, pm_qos_show, pm_qos_store);
7149+static DEVICE_ATTR(pm_qos_state, S_IRUGO, pm_qos_state_show, NULL);
7150+ANDROID_DEV_ATTR(up_pm_qos_sample_sec, "%u\n");
7151+ANDROID_DEV_ATTR(down_pm_qos_sample_sec, "%u\n");
7152+ANDROID_DEV_ATTR(up_pm_qos_threshold, "%u\n");
7153+ANDROID_DEV_ATTR(down_pm_qos_threshold, "%u\n");
7154+ANDROID_DEV_ATTR(idle_pc_rpm_no_int_secs, "%u\n");
7155+
7156 static DEVICE_ATTR(state, S_IRUGO, state_show, NULL);
7157+static DEVICE_ATTR(remote_wakeup, S_IRUGO | S_IWUSR,
7158+ remote_wakeup_show, remote_wakeup_store);
7159
7160 static struct device_attribute *android_usb_attributes[] = {
7161 &dev_attr_idVendor,
7162@@ -1751,7 +3411,15 @@ static struct device_attribute *android_usb_attributes[] = {
7163 &dev_attr_iSerial,
7164 &dev_attr_functions,
7165 &dev_attr_enable,
7166+ &dev_attr_pm_qos,
7167+ &dev_attr_up_pm_qos_sample_sec,
7168+ &dev_attr_down_pm_qos_sample_sec,
7169+ &dev_attr_up_pm_qos_threshold,
7170+ &dev_attr_down_pm_qos_threshold,
7171+ &dev_attr_idle_pc_rpm_no_int_secs,
7172+ &dev_attr_pm_qos_state,
7173 &dev_attr_state,
7174+ &dev_attr_remote_wakeup,
7175 NULL
7176 };
7177
7178@@ -1760,7 +3428,7 @@ static struct device_attribute *android_usb_attributes[] = {
7179
7180 static int android_bind_config(struct usb_configuration *c)
7181 {
7182- struct android_dev *dev = _android_dev;
7183+ struct android_dev *dev = cdev_to_android_dev(c->cdev);
7184 int ret = 0;
7185
7186 ret = android_bind_enabled_functions(dev, c);
7187@@ -1772,26 +3440,42 @@ static int android_bind_config(struct usb_configuration *c)
7188
7189 static void android_unbind_config(struct usb_configuration *c)
7190 {
7191- struct android_dev *dev = _android_dev;
7192+ struct android_dev *dev = cdev_to_android_dev(c->cdev);
7193
7194+ if (c->cdev->gadget->streaming_enabled) {
7195+ c->cdev->gadget->streaming_enabled = false;
7196+ pr_debug("setting streaming_enabled to false.\n");
7197+ }
7198 android_unbind_enabled_functions(dev, c);
7199 }
7200
7201 static int android_bind(struct usb_composite_dev *cdev)
7202 {
7203- struct android_dev *dev = _android_dev;
7204+ struct android_dev *dev;
7205 struct usb_gadget *gadget = cdev->gadget;
7206+ struct android_configuration *conf;
7207 int id, ret;
7208
7209+ /* Bind to the last android_dev that was probed */
7210+ dev = list_entry(android_dev_list.prev, struct android_dev, list_item);
7211+
7212+ dev->cdev = cdev;
7213+
7214+ /* Save the default handler */
7215+ dev->setup_complete = cdev->req->complete;
7216+
7217 /*
7218 * Start disconnected. Userspace will connect the gadget once
7219 * it is done configuring the functions.
7220 */
7221 usb_gadget_disconnect(gadget);
7222
7223- ret = android_init_functions(dev->functions, cdev);
7224- if (ret)
7225- return ret;
7226+ /* Init the supported functions only once, on the first android_dev */
7227+ if (android_dev_count == 1) {
7228+ ret = android_init_functions(dev->functions, cdev);
7229+ if (ret)
7230+ return ret;
7231+ }
7232
7233 /* Allocate string descriptor numbers ... note that string
7234 * contents can be overridden by the composite_dev glue.
7235@@ -1809,9 +3493,10 @@ static int android_bind(struct usb_composite_dev *cdev)
7236 device_desc.iProduct = id;
7237
7238 /* Default strings - should be updated by userspace */
7239- strncpy(manufacturer_string, "Android", sizeof(manufacturer_string)-1);
7240- strncpy(product_string, "Android", sizeof(product_string) - 1);
7241- strncpy(serial_string, "0123456789ABCDEF", sizeof(serial_string) - 1);
7242+ strlcpy(manufacturer_string, "Android",
7243+ sizeof(manufacturer_string) - 1);
7244+ strlcpy(product_string, "Android", sizeof(product_string) - 1);
7245+ strlcpy(serial_string, "0123456789ABCDEF", sizeof(serial_string) - 1);
7246
7247 id = usb_string_id(cdev);
7248 if (id < 0)
7249@@ -1819,46 +3504,68 @@ static int android_bind(struct usb_composite_dev *cdev)
7250 strings_dev[STRING_SERIAL_IDX].id = id;
7251 device_desc.iSerialNumber = id;
7252
7253- usb_gadget_set_selfpowered(gadget);
7254- dev->cdev = cdev;
7255+ if (gadget_is_otg(cdev->gadget))
7256+ list_for_each_entry(conf, &dev->configs, list_item)
7257+ conf->usb_config.descriptors = otg_desc;
7258
7259 return 0;
7260 }
7261
7262 static int android_usb_unbind(struct usb_composite_dev *cdev)
7263 {
7264- struct android_dev *dev = _android_dev;
7265+ struct android_dev *dev = cdev_to_android_dev(cdev);
7266
7267+ manufacturer_string[0] = '\0';
7268+ product_string[0] = '\0';
7269+ serial_string[0] = '0';
7270 cancel_work_sync(&dev->work);
7271+ cancel_delayed_work_sync(&dev->pm_qos_work);
7272 android_cleanup_functions(dev->functions);
7273 return 0;
7274 }
7275
7276 /* HACK: android needs to override setup for accessory to work */
7277 static int (*composite_setup_func)(struct usb_gadget *gadget, const struct usb_ctrlrequest *c);
7278+static void (*composite_suspend_func)(struct usb_gadget *gadget);
7279+static void (*composite_resume_func)(struct usb_gadget *gadget);
7280
7281 static int
7282 android_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)
7283 {
7284- struct android_dev *dev = _android_dev;
7285 struct usb_composite_dev *cdev = get_gadget_data(gadget);
7286+ struct android_dev *dev = cdev_to_android_dev(cdev);
7287 struct usb_request *req = cdev->req;
7288 struct android_usb_function *f;
7289+ struct android_usb_function_holder *f_holder;
7290+ struct android_configuration *conf;
7291 int value = -EOPNOTSUPP;
7292 unsigned long flags;
7293+ bool do_work = false;
7294+ bool prev_configured = false;
7295
7296 req->zero = 0;
7297 req->length = 0;
7298+ req->complete = dev->setup_complete;
7299 gadget->ep0->driver_data = cdev;
7300
7301- list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
7302- if (f->ctrlrequest) {
7303- value = f->ctrlrequest(f, cdev, c);
7304- if (value >= 0)
7305- break;
7306+ list_for_each_entry(conf, &dev->configs, list_item)
7307+ list_for_each_entry(f_holder,
7308+ &conf->enabled_functions,
7309+ enabled_list) {
7310+ f = f_holder->f;
7311+ if (f->ctrlrequest) {
7312+ value = f->ctrlrequest(f, cdev, c);
7313+ if (value >= 0)
7314+ break;
7315+ }
7316 }
7317- }
7318
7319+ /*
7320+ * skip the work when 2nd set config arrives
7321+ * with same value from the host.
7322+ */
7323+ if (cdev->config)
7324+ prev_configured = true;
7325 /* Special case the accessory function.
7326 * It needs to handle control requests before it is enabled.
7327 */
7328@@ -1871,19 +3578,21 @@ android_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)
7329 spin_lock_irqsave(&cdev->lock, flags);
7330 if (!dev->connected) {
7331 dev->connected = 1;
7332- schedule_work(&dev->work);
7333+ do_work = true;
7334 } else if (c->bRequest == USB_REQ_SET_CONFIGURATION &&
7335 cdev->config) {
7336- schedule_work(&dev->work);
7337+ if (!prev_configured)
7338+ do_work = true;
7339 }
7340 spin_unlock_irqrestore(&cdev->lock, flags);
7341-
7342+ if (do_work)
7343+ schedule_work(&dev->work);
7344 return value;
7345 }
7346
7347 static void android_disconnect(struct usb_composite_dev *cdev)
7348 {
7349- struct android_dev *dev = _android_dev;
7350+ struct android_dev *dev = cdev_to_android_dev(cdev);
7351
7352 /* accessory HID support can be active while the
7353 accessory function is not actually enabled,
7354@@ -1902,17 +3611,57 @@ static struct usb_composite_driver android_usb_driver = {
7355 .bind = android_bind,
7356 .unbind = android_usb_unbind,
7357 .disconnect = android_disconnect,
7358- .max_speed = USB_SPEED_HIGH,
7359+ .max_speed = USB_SPEED_SUPER
7360 };
7361
7362-static int android_create_device(struct android_dev *dev)
7363+static void android_suspend(struct usb_gadget *gadget)
7364+{
7365+ struct usb_composite_dev *cdev = get_gadget_data(gadget);
7366+ struct android_dev *dev = cdev_to_android_dev(cdev);
7367+ unsigned long flags;
7368+
7369+ spin_lock_irqsave(&cdev->lock, flags);
7370+ if (!dev->suspended) {
7371+ dev->suspended = 1;
7372+ schedule_work(&dev->work);
7373+ }
7374+ spin_unlock_irqrestore(&cdev->lock, flags);
7375+
7376+ composite_suspend_func(gadget);
7377+}
7378+
7379+static void android_resume(struct usb_gadget *gadget)
7380+{
7381+ struct usb_composite_dev *cdev = get_gadget_data(gadget);
7382+ struct android_dev *dev = cdev_to_android_dev(cdev);
7383+ unsigned long flags;
7384+
7385+ spin_lock_irqsave(&cdev->lock, flags);
7386+ if (dev->suspended) {
7387+ dev->suspended = 0;
7388+ schedule_work(&dev->work);
7389+ }
7390+ spin_unlock_irqrestore(&cdev->lock, flags);
7391+
7392+ composite_resume_func(gadget);
7393+}
7394+
7395+static int android_create_device(struct android_dev *dev, u8 usb_core_id)
7396 {
7397 struct device_attribute **attrs = android_usb_attributes;
7398 struct device_attribute *attr;
7399+ char device_node_name[ANDROID_DEVICE_NODE_NAME_LENGTH];
7400 int err;
7401
7402- dev->dev = device_create(android_class, NULL,
7403- MKDEV(0, 0), NULL, "android0");
7404+ /*
7405+ * The primary usb core should always have usb_core_id=0, since
7406+ * Android user space is currently interested in android0 events.
7407+ */
7408+ snprintf(device_node_name, ANDROID_DEVICE_NODE_NAME_LENGTH,
7409+ "android%d", usb_core_id);
7410+ pr_debug("%s(): creating android%d device\n", __func__, usb_core_id);
7411+ dev->dev = device_create(android_class, NULL, MKDEV(0, usb_core_id),
7412+ NULL, device_node_name);
7413 if (IS_ERR(dev->dev))
7414 return PTR_ERR(dev->dev);
7415
7416@@ -1928,63 +3677,348 @@ static int android_create_device(struct android_dev *dev)
7417 return 0;
7418 }
7419
7420+static void android_destroy_device(struct android_dev *dev)
7421+{
7422+ struct device_attribute **attrs = android_usb_attributes;
7423+ struct device_attribute *attr;
7424
7425-static int __init init(void)
7426+ while ((attr = *attrs++))
7427+ device_remove_file(dev->dev, attr);
7428+ device_destroy(android_class, dev->dev->devt);
7429+}
7430+
7431+static struct android_dev *cdev_to_android_dev(struct usb_composite_dev *cdev)
7432 {
7433- struct android_dev *dev;
7434- int err;
7435+ struct android_dev *dev = NULL;
7436
7437- android_class = class_create(THIS_MODULE, "android_usb");
7438- if (IS_ERR(android_class))
7439- return PTR_ERR(android_class);
7440+ /* Find the android dev from the list */
7441+ list_for_each_entry(dev, &android_dev_list, list_item) {
7442+ if (dev->cdev == cdev)
7443+ break;
7444+ }
7445
7446- dev = kzalloc(sizeof(*dev), GFP_KERNEL);
7447- if (!dev) {
7448- err = -ENOMEM;
7449- goto err_dev;
7450+ return dev;
7451+}
7452+
7453+static struct android_configuration *alloc_android_config
7454+ (struct android_dev *dev)
7455+{
7456+ struct android_configuration *conf;
7457+
7458+ conf = kzalloc(sizeof(*conf), GFP_KERNEL);
7459+ if (!conf) {
7460+ pr_err("%s(): Failed to alloc memory for android conf\n",
7461+ __func__);
7462+ return ERR_PTR(-ENOMEM);
7463 }
7464
7465- dev->disable_depth = 1;
7466- dev->functions = supported_functions;
7467- INIT_LIST_HEAD(&dev->enabled_functions);
7468- INIT_WORK(&dev->work, android_work);
7469- mutex_init(&dev->mutex);
7470+ dev->configs_num++;
7471+ conf->usb_config.label = dev->name;
7472+ conf->usb_config.unbind = android_unbind_config;
7473+ conf->usb_config.bConfigurationValue = dev->configs_num;
7474
7475- err = android_create_device(dev);
7476- if (err) {
7477- pr_err("%s: failed to create android device %d", __func__, err);
7478- goto err_create;
7479+ INIT_LIST_HEAD(&conf->enabled_functions);
7480+
7481+ list_add_tail(&conf->list_item, &dev->configs);
7482+
7483+ return conf;
7484+}
7485+
7486+static void free_android_config(struct android_dev *dev,
7487+ struct android_configuration *conf)
7488+{
7489+ list_del(&conf->list_item);
7490+ dev->configs_num--;
7491+ kfree(conf);
7492+}
7493+
7494+static int usb_diag_update_pid_and_serial_num(u32 pid, const char *snum)
7495+{
7496+ struct dload_struct local_diag_dload = { 0 };
7497+ int *src, *dst, i;
7498+
7499+ if (!diag_dload) {
7500+ pr_debug("%s: unable to update PID and serial_no\n", __func__);
7501+ return -ENODEV;
7502 }
7503
7504- _android_dev = dev;
7505+ pr_debug("%s: dload:%p pid:%x serial_num:%s\n",
7506+ __func__, diag_dload, pid, snum);
7507
7508- err = usb_composite_probe(&android_usb_driver);
7509- if (err) {
7510- pr_err("%s: failed to probe driver %d", __func__, err);
7511- goto err_probe;
7512+ /* update pid */
7513+ local_diag_dload.magic_struct.pid = PID_MAGIC_ID;
7514+ local_diag_dload.pid = pid;
7515+
7516+ /* update serial number */
7517+ if (!snum) {
7518+ local_diag_dload.magic_struct.serial_num = 0;
7519+ memset(&local_diag_dload.serial_number, 0,
7520+ SERIAL_NUMBER_LENGTH);
7521+ } else {
7522+ local_diag_dload.magic_struct.serial_num = SERIAL_NUM_MAGIC_ID;
7523+ strlcpy((char *)&local_diag_dload.serial_number, snum,
7524+ SERIAL_NUMBER_LENGTH);
7525 }
7526
7527- /* HACK: exchange composite's setup with ours */
7528- composite_setup_func = android_usb_driver.gadget_driver.setup;
7529- android_usb_driver.gadget_driver.setup = android_setup;
7530+ /* Copy to shared struct (accesses need to be 32 bit aligned) */
7531+ src = (int *)&local_diag_dload;
7532+ dst = (int *)diag_dload;
7533+
7534+ for (i = 0; i < sizeof(*diag_dload) / 4; i++)
7535+ *dst++ = *src++;
7536
7537 return 0;
7538+}
7539+
7540+static int android_probe(struct platform_device *pdev)
7541+{
7542+ struct android_usb_platform_data *pdata;
7543+ struct android_dev *android_dev;
7544+ struct resource *res;
7545+ int ret = 0, i, len = 0, prop_len = 0;
7546+ u32 usb_core_id = 0;
7547+
7548+ if (pdev->dev.of_node) {
7549+ dev_dbg(&pdev->dev, "device tree enabled\n");
7550+ pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
7551+ if (!pdata) {
7552+ pr_err("unable to allocate platform data\n");
7553+ return -ENOMEM;
7554+ }
7555+
7556+ of_get_property(pdev->dev.of_node, "qcom,pm-qos-latency",
7557+ &prop_len);
7558+ if (prop_len == sizeof(pdata->pm_qos_latency)) {
7559+ of_property_read_u32_array(pdev->dev.of_node,
7560+ "qcom,pm-qos-latency", pdata->pm_qos_latency,
7561+ prop_len/sizeof(*pdata->pm_qos_latency));
7562+ } else {
7563+ pr_info("pm_qos latency not specified %d\n", prop_len);
7564+ }
7565+
7566+ ret = of_property_read_u32(pdev->dev.of_node,
7567+ "qcom,usb-core-id",
7568+ &usb_core_id);
7569+ if (!ret)
7570+ pdata->usb_core_id = usb_core_id;
7571+
7572+ len = of_property_count_strings(pdev->dev.of_node,
7573+ "qcom,streaming-func");
7574+ if (len > MAX_STREAMING_FUNCS) {
7575+ pr_err("Invalid number of functions used.\n");
7576+ return -EINVAL;
7577+ }
7578+
7579+ for (i = 0; i < len; i++) {
7580+ const char *name = NULL;
7581+
7582+ of_property_read_string_index(pdev->dev.of_node,
7583+ "qcom,streaming-func", i, &name);
7584+
7585+ if (!name)
7586+ continue;
7587
7588+ if (sizeof(name) > FUNC_NAME_LEN) {
7589+ pr_err("Function name is bigger than allowed.\n");
7590+ continue;
7591+ }
7592+
7593+ strlcpy(pdata->streaming_func[i], name,
7594+ sizeof(pdata->streaming_func[i]));
7595+ pr_debug("name of streaming function:%s\n",
7596+ pdata->streaming_func[i]);
7597+ }
7598+
7599+ pdata->streaming_func_count = len;
7600+
7601+ pdata->cdrom = of_property_read_bool(pdev->dev.of_node,
7602+ "qcom,android-usb-cdrom");
7603+ ret = of_property_read_u8(pdev->dev.of_node,
7604+ "qcom,android-usb-uicc-nluns",
7605+ &pdata->uicc_nluns);
7606+ } else {
7607+ pdata = pdev->dev.platform_data;
7608+ }
7609+
7610+ if (!android_class) {
7611+ android_class = class_create(THIS_MODULE, "android_usb");
7612+ if (IS_ERR(android_class))
7613+ return PTR_ERR(android_class);
7614+ }
7615+
7616+ android_dev = kzalloc(sizeof(*android_dev), GFP_KERNEL);
7617+ if (!android_dev) {
7618+ pr_err("%s(): Failed to alloc memory for android_dev\n",
7619+ __func__);
7620+ ret = -ENOMEM;
7621+ goto err_alloc;
7622+ }
7623+
7624+ android_dev->name = pdev->name;
7625+ android_dev->disable_depth = 1;
7626+ android_dev->functions = supported_functions;
7627+ android_dev->configs_num = 0;
7628+ INIT_LIST_HEAD(&android_dev->configs);
7629+ INIT_WORK(&android_dev->work, android_work);
7630+ INIT_DELAYED_WORK(&android_dev->pm_qos_work, android_pm_qos_work);
7631+ mutex_init(&android_dev->mutex);
7632+
7633+ android_dev->pdata = pdata;
7634+
7635+ list_add_tail(&android_dev->list_item, &android_dev_list);
7636+ android_dev_count++;
7637+
7638+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
7639+ if (res) {
7640+ diag_dload = devm_ioremap(&pdev->dev, res->start,
7641+ resource_size(res));
7642+ if (!diag_dload) {
7643+ dev_err(&pdev->dev, "ioremap failed\n");
7644+ ret = -ENOMEM;
7645+ goto err_dev;
7646+ }
7647+ } else {
7648+ dev_dbg(&pdev->dev, "failed to get mem resource\n");
7649+ }
7650+
7651+ if (pdata)
7652+ android_usb_driver.gadget_driver.usb_core_id =
7653+ pdata->usb_core_id;
7654+ ret = android_create_device(android_dev,
7655+ android_usb_driver.gadget_driver.usb_core_id);
7656+ if (ret) {
7657+ pr_err("%s(): android_create_device failed\n", __func__);
7658+ goto err_dev;
7659+ }
7660+
7661+ pr_debug("%s(): registering android_usb_driver with core id:%d\n",
7662+ __func__, android_usb_driver.gadget_driver.usb_core_id);
7663+ ret = usb_composite_probe(&android_usb_driver);
7664+ if (ret) {
7665+ /* Perhaps UDC hasn't probed yet, try again later */
7666+ if (ret == -ENODEV)
7667+ ret = -EPROBE_DEFER;
7668+ else
7669+ pr_err("%s(): Failed to register android composite driver\n",
7670+ __func__);
7671+ goto err_probe;
7672+ }
7673+
7674+ /* pm qos request to prevent apps idle power collapse */
7675+ android_dev->curr_pm_qos_state = NO_USB_VOTE;
7676+ if (pdata && pdata->pm_qos_latency[0]) {
7677+ pm_qos_add_request(&android_dev->pm_qos_req_dma,
7678+ PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE);
7679+ android_dev->down_pm_qos_sample_sec = DOWN_PM_QOS_SAMPLE_SEC;
7680+ android_dev->down_pm_qos_threshold = DOWN_PM_QOS_THRESHOLD;
7681+ android_dev->up_pm_qos_sample_sec = UP_PM_QOS_SAMPLE_SEC;
7682+ android_dev->up_pm_qos_threshold = UP_PM_QOS_THRESHOLD;
7683+ android_dev->idle_pc_rpm_no_int_secs = IDLE_PC_RPM_NO_INT_SECS;
7684+ }
7685+ strlcpy(android_dev->pm_qos, "high", sizeof(android_dev->pm_qos));
7686+
7687+ return ret;
7688 err_probe:
7689- device_destroy(android_class, dev->dev->devt);
7690-err_create:
7691- kfree(dev);
7692+ android_destroy_device(android_dev);
7693 err_dev:
7694- class_destroy(android_class);
7695- return err;
7696+ list_del(&android_dev->list_item);
7697+ android_dev_count--;
7698+ kfree(android_dev);
7699+err_alloc:
7700+ if (list_empty(&android_dev_list)) {
7701+ class_destroy(android_class);
7702+ android_class = NULL;
7703+ }
7704+ return ret;
7705+}
7706+
7707+static int android_remove(struct platform_device *pdev)
7708+{
7709+ struct android_dev *dev = NULL;
7710+ struct android_usb_platform_data *pdata = pdev->dev.platform_data;
7711+ int usb_core_id = 0;
7712+
7713+ if (pdata)
7714+ usb_core_id = pdata->usb_core_id;
7715+
7716+ /* Find the android dev from the list */
7717+ list_for_each_entry(dev, &android_dev_list, list_item) {
7718+ if (!dev->pdata)
7719+ break; /*To backward compatibility*/
7720+ if (dev->pdata->usb_core_id == usb_core_id)
7721+ break;
7722+ }
7723+
7724+ if (dev) {
7725+ android_destroy_device(dev);
7726+ if (pdata && pdata->pm_qos_latency[0])
7727+ pm_qos_remove_request(&dev->pm_qos_req_dma);
7728+ list_del(&dev->list_item);
7729+ android_dev_count--;
7730+ kfree(dev);
7731+ }
7732+
7733+ if (list_empty(&android_dev_list)) {
7734+ class_destroy(android_class);
7735+ android_class = NULL;
7736+ usb_composite_unregister(&android_usb_driver);
7737+ }
7738+
7739+ return 0;
7740+}
7741+
7742+static const struct platform_device_id android_id_table[] = {
7743+ {
7744+ .name = "android_usb",
7745+ },
7746+ {
7747+ .name = "android_usb_hsic",
7748+ },
7749+};
7750+
7751+static struct of_device_id usb_android_dt_match[] = {
7752+ { .compatible = "qcom,android-usb",
7753+ },
7754+ {}
7755+};
7756+
7757+static struct platform_driver android_platform_driver = {
7758+ .driver = {
7759+ .name = "android_usb",
7760+ .of_match_table = usb_android_dt_match,
7761+ },
7762+ .probe = android_probe,
7763+ .remove = android_remove,
7764+ .id_table = android_id_table,
7765+};
7766+
7767+static int __init init(void)
7768+{
7769+ int ret;
7770+
7771+ INIT_LIST_HEAD(&android_dev_list);
7772+ android_dev_count = 0;
7773+
7774+ ret = platform_driver_register(&android_platform_driver);
7775+ if (ret) {
7776+ pr_err("%s(): Failed to register android"
7777+ "platform driver\n", __func__);
7778+ }
7779+
7780+ /* HACK: exchange composite's setup with ours */
7781+ composite_setup_func = android_usb_driver.gadget_driver.setup;
7782+ android_usb_driver.gadget_driver.setup = android_setup;
7783+ composite_suspend_func = android_usb_driver.gadget_driver.suspend;
7784+ android_usb_driver.gadget_driver.suspend = android_suspend;
7785+ composite_resume_func = android_usb_driver.gadget_driver.resume;
7786+ android_usb_driver.gadget_driver.resume = android_resume;
7787+
7788+ return ret;
7789 }
7790 late_initcall(init);
7791
7792 static void __exit cleanup(void)
7793 {
7794- usb_composite_unregister(&android_usb_driver);
7795- class_destroy(android_class);
7796- kfree(_android_dev);
7797- _android_dev = NULL;
7798+ platform_driver_unregister(&android_platform_driver);
7799 }
7800 module_exit(cleanup);
7801diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
7802index 2ec1a44..6bd85d9 100644
7803--- a/drivers/usb/gadget/composite.c
7804+++ b/drivers/usb/gadget/composite.c
7805@@ -33,9 +33,6 @@ static struct usb_gadget_strings **get_containers_gs(
7806 {
7807 return (struct usb_gadget_strings **)uc->stash;
7808 }
7809-#define USB_PRE_CONFIG_CURRENT 100
7810-#define USB_OTG_PRE_CONFIG_CURRENT 2
7811-
7812
7813 /**
7814 * next_ep_desc() - advance to the next EP descriptor
7815@@ -341,6 +338,113 @@ int usb_interface_id(struct usb_configuration *config,
7816 }
7817 EXPORT_SYMBOL_GPL(usb_interface_id);
7818
7819+/**
7820+ * usb_get_func_interface_id() - Find the interface ID of a function
7821+ * @function: the function for which want to find the interface ID
7822+ * Context: single threaded
7823+ *
7824+ * Returns the interface ID of the function or -ENODEV if this function
7825+ * is not part of this configuration
7826+ */
7827+int usb_get_func_interface_id(struct usb_function *func)
7828+{
7829+ int id;
7830+ struct usb_configuration *config;
7831+
7832+ if (!func)
7833+ return -EINVAL;
7834+
7835+ config = func->config;
7836+
7837+ for (id = 0; id < MAX_CONFIG_INTERFACES; id++) {
7838+ if (config->interface[id] == func)
7839+ return id;
7840+ }
7841+ return -ENODEV;
7842+}
7843+
7844+static int usb_func_wakeup_int(struct usb_function *func,
7845+ bool use_pending_flag)
7846+{
7847+ int ret;
7848+ int interface_id;
7849+ unsigned long flags;
7850+ struct usb_gadget *gadget;
7851+ struct usb_composite_dev *cdev;
7852+
7853+ pr_debug("%s - %s function wakeup, use pending: %u\n",
7854+ __func__, func->name ? func->name : "", use_pending_flag);
7855+
7856+ if (!func || !func->config || !func->config->cdev ||
7857+ !func->config->cdev->gadget)
7858+ return -EINVAL;
7859+
7860+ gadget = func->config->cdev->gadget;
7861+ if ((gadget->speed != USB_SPEED_SUPER) || !func->func_wakeup_allowed) {
7862+ DBG(func->config->cdev,
7863+ "Function Wakeup is not possible. speed=%u, func_wakeup_allowed=%u\n",
7864+ gadget->speed,
7865+ func->func_wakeup_allowed);
7866+
7867+ return -ENOTSUPP;
7868+ }
7869+
7870+ cdev = get_gadget_data(gadget);
7871+ spin_lock_irqsave(&cdev->lock, flags);
7872+
7873+ if (use_pending_flag && !func->func_wakeup_pending) {
7874+ pr_debug("Pending flag is cleared - Function wakeup is cancelled.\n");
7875+ spin_unlock_irqrestore(&cdev->lock, flags);
7876+ return 0;
7877+ }
7878+
7879+ ret = usb_get_func_interface_id(func);
7880+ if (ret < 0) {
7881+ ERROR(func->config->cdev,
7882+ "Function %s - Unknown interface id. Canceling USB request. ret=%d\n",
7883+ func->name ? func->name : "", ret);
7884+
7885+ spin_unlock_irqrestore(&cdev->lock, flags);
7886+ return ret;
7887+ }
7888+
7889+ interface_id = ret;
7890+ ret = usb_gadget_func_wakeup(gadget, interface_id);
7891+
7892+ if (use_pending_flag) {
7893+ func->func_wakeup_pending = false;
7894+ } else {
7895+ if (ret == -EAGAIN)
7896+ func->func_wakeup_pending = true;
7897+ }
7898+
7899+ spin_unlock_irqrestore(&cdev->lock, flags);
7900+
7901+ return ret;
7902+}
7903+
7904+int usb_func_wakeup(struct usb_function *func)
7905+{
7906+ int ret;
7907+
7908+ pr_debug("%s function wakeup\n",
7909+ func->name ? func->name : "");
7910+
7911+ ret = usb_func_wakeup_int(func, false);
7912+ if (ret == -EAGAIN) {
7913+ DBG(func->config->cdev,
7914+ "Function wakeup for %s could not complete due to suspend state. Delayed until after bus resume.\n",
7915+ func->name ? func->name : "");
7916+ ret = 0;
7917+ } else if (ret < 0 && ret != -ENOTSUPP) {
7918+ ERROR(func->config->cdev,
7919+ "Failed to wake function %s from suspend state. ret=%d. Canceling USB request.\n",
7920+ func->name ? func->name : "", ret);
7921+ }
7922+
7923+ return ret;
7924+}
7925+
7926 static u8 encode_bMaxPower(enum usb_device_speed speed,
7927 struct usb_configuration *c)
7928 {
7929@@ -523,7 +627,8 @@ static int bos_desc(struct usb_composite_dev *cdev)
7930
7931 /*
7932 * A SuperSpeed device shall include the USB2.0 extension descriptor
7933- * and shall support LPM when operating in USB2.0 HS mode.
7934+ * and shall support LPM when operating in USB2.0 HS mode, as well as
7935+ * a HS device when operating in USB2.1 HS mode.
7936 */
7937 usb_ext = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
7938 bos->bNumDeviceCaps++;
7939@@ -533,33 +638,37 @@ static int bos_desc(struct usb_composite_dev *cdev)
7940 usb_ext->bDevCapabilityType = USB_CAP_TYPE_EXT;
7941 usb_ext->bmAttributes = cpu_to_le32(USB_LPM_SUPPORT);
7942
7943- /*
7944- * The Superspeed USB Capability descriptor shall be implemented by all
7945- * SuperSpeed devices.
7946- */
7947- ss_cap = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
7948- bos->bNumDeviceCaps++;
7949- le16_add_cpu(&bos->wTotalLength, USB_DT_USB_SS_CAP_SIZE);
7950- ss_cap->bLength = USB_DT_USB_SS_CAP_SIZE;
7951- ss_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
7952- ss_cap->bDevCapabilityType = USB_SS_CAP_TYPE;
7953- ss_cap->bmAttributes = 0; /* LTM is not supported yet */
7954- ss_cap->wSpeedSupported = cpu_to_le16(USB_LOW_SPEED_OPERATION |
7955- USB_FULL_SPEED_OPERATION |
7956- USB_HIGH_SPEED_OPERATION |
7957- USB_5GBPS_OPERATION);
7958- ss_cap->bFunctionalitySupport = USB_LOW_SPEED_OPERATION;
7959-
7960- /* Get Controller configuration */
7961- if (cdev->gadget->ops->get_config_params)
7962- cdev->gadget->ops->get_config_params(&dcd_config_params);
7963- else {
7964- dcd_config_params.bU1devExitLat = USB_DEFAULT_U1_DEV_EXIT_LAT;
7965- dcd_config_params.bU2DevExitLat =
7966- cpu_to_le16(USB_DEFAULT_U2_DEV_EXIT_LAT);
7967+ if (gadget_is_superspeed(cdev->gadget)) {
7968+ /*
7969+ * The Superspeed USB Capability descriptor shall be
7970+ * implemented by all SuperSpeed devices.
7971+ */
7972+ ss_cap = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
7973+ bos->bNumDeviceCaps++;
7974+ le16_add_cpu(&bos->wTotalLength, USB_DT_USB_SS_CAP_SIZE);
7975+ ss_cap->bLength = USB_DT_USB_SS_CAP_SIZE;
7976+ ss_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
7977+ ss_cap->bDevCapabilityType = USB_SS_CAP_TYPE;
7978+ ss_cap->bmAttributes = 0; /* LTM is not supported yet */
7979+ ss_cap->wSpeedSupported = cpu_to_le16(USB_LOW_SPEED_OPERATION |
7980+ USB_FULL_SPEED_OPERATION |
7981+ USB_HIGH_SPEED_OPERATION |
7982+ USB_5GBPS_OPERATION);
7983+ ss_cap->bFunctionalitySupport = USB_LOW_SPEED_OPERATION;
7984+
7985+ /* Get Controller configuration */
7986+ if (cdev->gadget->ops->get_config_params)
7987+ cdev->gadget->ops->get_config_params
7988+ (&dcd_config_params);
7989+ else {
7990+ dcd_config_params.bU1devExitLat =
7991+ USB_DEFAULT_U1_DEV_EXIT_LAT;
7992+ dcd_config_params.bU2DevExitLat =
7993+ cpu_to_le16(USB_DEFAULT_U2_DEV_EXIT_LAT);
7994+ }
7995+ ss_cap->bU1devExitLat = dcd_config_params.bU1devExitLat;
7996+ ss_cap->bU2DevExitLat = dcd_config_params.bU2DevExitLat;
7997 }
7998- ss_cap->bU1devExitLat = dcd_config_params.bU1devExitLat;
7999- ss_cap->bU2DevExitLat = dcd_config_params.bU2DevExitLat;
8000
8001 return le16_to_cpu(bos->wTotalLength);
8002 }
8003@@ -593,9 +702,15 @@ static void reset_config(struct usb_composite_dev *cdev)
8004 if (f->disable)
8005 f->disable(f);
8006
8007+ /* USB 3.0 addition */
8008+ f->func_is_suspended = false;
8009+ f->func_wakeup_allowed = false;
8010+ f->func_wakeup_pending = false;
8011+
8012 bitmap_zero(f->endpoints, 32);
8013 }
8014 cdev->config = NULL;
8015+ cdev->delayed_status = 0;
8016 }
8017
8018 static int set_config(struct usb_composite_dev *cdev,
8019@@ -607,6 +722,16 @@ static int set_config(struct usb_composite_dev *cdev,
8020 unsigned power = gadget_is_otg(gadget) ? 8 : 100;
8021 int tmp;
8022
8023+ /*
8024+ * ignore 2nd time SET_CONFIGURATION
8025+ * only for same config value twice.
8026+ */
8027+ if (cdev->config && (cdev->config->bConfigurationValue == number)) {
8028+ DBG(cdev, "already in the same config with value %d\n",
8029+ number);
8030+ return 0;
8031+ }
8032+
8033 if (number) {
8034 list_for_each_entry(c, &cdev->configs, list) {
8035 if (c->bConfigurationValue == number) {
8036@@ -637,6 +762,8 @@ static int set_config(struct usb_composite_dev *cdev,
8037 goto done;
8038
8039 cdev->config = c;
8040+ c->num_ineps_used = 0;
8041+ c->num_outeps_used = 0;
8042
8043 /* Initialize all interfaces by setting them to altsetting zero. */
8044 for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
8045@@ -674,6 +801,10 @@ static int set_config(struct usb_composite_dev *cdev,
8046 addr = ((ep->bEndpointAddress & 0x80) >> 3)
8047 | (ep->bEndpointAddress & 0x0f);
8048 set_bit(addr, f->endpoints);
8049+ if (usb_endpoint_dir_in(ep))
8050+ c->num_ineps_used++;
8051+ else
8052+ c->num_outeps_used++;
8053 }
8054
8055 result = f->set_alt(f, tmp, 0);
8056@@ -852,6 +983,11 @@ void usb_remove_config(struct usb_composite_dev *cdev,
8057
8058 spin_lock_irqsave(&cdev->lock, flags);
8059
8060+ if (WARN_ON(!config->cdev)) {
8061+ spin_unlock_irqrestore(&cdev->lock, flags);
8062+ return;
8063+ }
8064+
8065 if (cdev->config == config)
8066 reset_config(cdev);
8067
8068@@ -1229,7 +1365,11 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
8069 u16 w_length = le16_to_cpu(ctrl->wLength);
8070 struct usb_function *f = NULL;
8071 u8 endp;
8072- struct usb_otg_descriptor* potgdesc;
8073+ struct usb_configuration *c;
8074+
8075+
8076+ if (w_length > USB_COMP_EP0_BUFSIZ)
8077+ return value;
8078
8079 /* partial re-init of the response message; the function or the
8080 * gadget might need to intercept e.g. a control-OUT completion
8081@@ -1260,22 +1400,14 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
8082 } else {
8083 cdev->desc.bcdUSB = cpu_to_le16(0x0210);
8084 }
8085+ } else if (gadget->l1_supported) {
8086+ cdev->desc.bcdUSB = cpu_to_le16(0x0201);
8087+ DBG(cdev, "Config HS device with LPM(L1)\n");
8088 }
8089
8090 value = min(w_length, (u16) sizeof cdev->desc);
8091 memcpy(req->buf, &cdev->desc, value);
8092 break;
8093-
8094- case USB_DT_OTG:
8095- value = min(w_length, (u16) sizeof(struct usb_otg_descriptor));
8096- potgdesc = (struct usb_otg_descriptor* )req->buf;
8097- potgdesc->bLength = (u16) sizeof(struct usb_otg_descriptor);
8098- potgdesc->bDescriptorType = USB_DT_OTG;
8099- potgdesc->bmAttributes = 0;
8100- potgdesc->bcdOTG = __constant_cpu_to_le16(0x0200);
8101-
8102- break;
8103-
8104 case USB_DT_DEVICE_QUALIFIER:
8105 if (!gadget_is_dualspeed(gadget) ||
8106 gadget->speed >= USB_SPEED_SUPER)
8107@@ -1294,6 +1426,17 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
8108 if (value >= 0)
8109 value = min(w_length, (u16) value);
8110 break;
8111+ case USB_DT_OTG:
8112+ if (!gadget_is_otg(gadget))
8113+ break;
8114+ c = list_first_entry(&cdev->configs,
8115+ struct usb_configuration, list);
8116+ if (c && c->descriptors)
8117+ value = usb_find_descriptor_fillbuf(req->buf,
8118+ USB_COMP_EP0_BUFSIZ,
8119+ c->descriptors,
8120+ USB_DT_OTG);
8121+ break;
8122 case USB_DT_STRING:
8123 value = get_string(cdev, req->buf,
8124 w_index, w_value & 0xff);
8125@@ -1301,7 +1444,8 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
8126 value = min(w_length, (u16) value);
8127 break;
8128 case USB_DT_BOS:
8129- if (gadget_is_superspeed(gadget)) {
8130+ if (gadget_is_superspeed(gadget) ||
8131+ gadget->l1_supported) {
8132 value = bos_desc(cdev);
8133 value = min(w_length, (u16) value);
8134 }
8135@@ -1348,6 +1492,15 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
8136 break;
8137 if (w_value && !f->set_alt)
8138 break;
8139+ /*
8140+ * We put interfaces in default settings (alt 0)
8141+ * upon set config#1. Call set_alt for non-zero
8142+ * alternate setting.
8143+ */
8144+ if (!w_value && cdev->config && !f->get_alt) {
8145+ value = 0;
8146+ break;
8147+ }
8148 value = f->set_alt(f, w_index, w_value);
8149 if (value == USB_GADGET_DELAYED_STATUS) {
8150 DBG(cdev,
8151@@ -1417,8 +1570,13 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
8152 if (!f)
8153 break;
8154 value = 0;
8155- if (f->func_suspend)
8156- value = f->func_suspend(f, w_index >> 8);
8157+ if (f->func_suspend) {
8158+ const u8 suspend_opt = w_index >> 8;
8159+
8160+ value = f->func_suspend(f, suspend_opt);
8161+ DBG(cdev, "%s function: FUNCTION_SUSPEND(%u)",
8162+ f->name ? f->name : "", suspend_opt);
8163+ }
8164 if (value < 0) {
8165 ERROR(cdev,
8166 "func_suspend() returned error %d\n",
8167@@ -1470,6 +1628,14 @@ unknown:
8168 if (c && c->setup)
8169 value = c->setup(c, ctrl);
8170 }
8171+ if (f && value == USB_GADGET_DELAYED_STATUS) {
8172+ DBG(cdev,
8173+ "%s: interface %d (%s) requested delayed status\n",
8174+ __func__, intf, f->name);
8175+ cdev->delayed_status++;
8176+ DBG(cdev, "delayed_status count %d\n",
8177+ cdev->delayed_status);
8178+ }
8179
8180 goto done;
8181 }
8182@@ -1508,11 +1674,11 @@ void composite_disconnect(struct usb_gadget *gadget)
8183 reset_config(cdev);
8184 if (cdev->driver->disconnect)
8185 cdev->driver->disconnect(cdev);
8186+ if (cdev->delayed_status != 0) {
8187+ INFO(cdev, "delayed status mismatch..resetting\n");
8188+ cdev->delayed_status = 0;
8189+ }
8190 spin_unlock_irqrestore(&cdev->lock, flags);
8191-
8192- usb_gadget_vbus_draw(gadget,
8193- gadget_is_otg(gadget) ? USB_OTG_PRE_CONFIG_CURRENT :
8194- USB_PRE_CONFIG_CURRENT);
8195 }
8196
8197 /*-------------------------------------------------------------------------*/
8198@@ -1737,6 +1903,7 @@ composite_resume(struct usb_gadget *gadget)
8199 struct usb_composite_dev *cdev = get_gadget_data(gadget);
8200 struct usb_function *f;
8201 u8 maxpower;
8202+ int ret;
8203
8204 /* REVISIT: should we have config level
8205 * suspend/resume callbacks?
8206@@ -1744,8 +1911,24 @@ composite_resume(struct usb_gadget *gadget)
8207 DBG(cdev, "resume\n");
8208 if (cdev->driver->resume)
8209 cdev->driver->resume(cdev);
8210+
8211 if (cdev->config) {
8212 list_for_each_entry(f, &cdev->config->functions, list) {
8213+ ret = usb_func_wakeup_int(f, true);
8214+ if (ret) {
8215+ if (ret == -EAGAIN) {
8216+ ERROR(f->config->cdev,
8217+ "Function wakeup for %s could not complete due to suspend state.\n",
8218+ f->name ? f->name : "");
8219+ break;
8220+ } else if (ret != -ENOTSUPP) {
8221+ ERROR(f->config->cdev,
8222+ "Failed to wake function %s from suspend state. ret=%d. Canceling USB request.\n",
8223+ f->name ? f->name : "",
8224+ ret);
8225+ }
8226+ }
8227+
8228 if (f->resume)
8229 f->resume(f);
8230 }
8231@@ -1795,6 +1978,7 @@ static const struct usb_gadget_driver composite_driver_template = {
8232 int usb_composite_probe(struct usb_composite_driver *driver)
8233 {
8234 struct usb_gadget_driver *gadget_driver;
8235+ u8 core_id;
8236
8237 if (!driver || !driver->dev || !driver->bind)
8238 return -EINVAL;
8239@@ -1802,6 +1986,7 @@ int usb_composite_probe(struct usb_composite_driver *driver)
8240 if (!driver->name)
8241 driver->name = "composite";
8242
8243+ core_id = driver->gadget_driver.usb_core_id;
8244 driver->gadget_driver = composite_driver_template;
8245 gadget_driver = &driver->gadget_driver;
8246
8247@@ -1809,6 +1994,11 @@ int usb_composite_probe(struct usb_composite_driver *driver)
8248 gadget_driver->driver.name = driver->name;
8249 gadget_driver->max_speed = driver->max_speed;
8250
8251+ if (core_id)
8252+ gadget_driver->usb_core_id = core_id;
8253+
8254+ pr_debug("%s(): gadget_driver->usb_core_id:%d\n", __func__,
8255+ gadget_driver->usb_core_id);
8256 return usb_gadget_probe_driver(gadget_driver);
8257 }
8258 EXPORT_SYMBOL_GPL(usb_composite_probe);
8259diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
8260index 8892f63..2ca35e52 100644
8261--- a/drivers/usb/gadget/f_acm.c
8262+++ b/drivers/usb/gadget/f_acm.c
8263@@ -5,6 +5,7 @@
8264 * Copyright (C) 2008 by David Brownell
8265 * Copyright (C) 2008 by Nokia Corporation
8266 * Copyright (C) 2009 by Samsung Electronics
8267+ * Copyright (c) 2011, 2014 The Linux Foundation. All rights reserved.
8268 * Author: Michal Nazarewicz (mina86@mina86.com)
8269 *
8270 * This software is distributed under the terms of the GNU General
8271@@ -20,12 +21,11 @@
8272 #include <linux/device.h>
8273 #include <linux/err.h>
8274
8275+#include "usb_gadget_xport.h"
8276 #include "u_serial.h"
8277 #include "gadget_chips.h"
8278
8279
8280-static struct acm_logging_callbacks *acm_logging_cb;
8281-
8282 /*
8283 * This CDC ACM function support just wraps control functions and
8284 * notifications around the generic serial-over-usb code.
8285@@ -47,6 +47,7 @@ struct f_acm {
8286 struct gserial port;
8287 u8 ctrl_id, data_id;
8288 u8 port_num;
8289+ enum transport_type transport;
8290
8291 u8 pending;
8292
8293@@ -77,6 +78,19 @@ struct f_acm {
8294 #define ACM_CTRL_DCD (1 << 0)
8295 };
8296
8297+static unsigned int no_acm_tty_ports;
8298+static unsigned int no_acm_smd_ports;
8299+static unsigned int nr_acm_ports;
8300+static unsigned int acm_next_free_port;
8301+
8302+#define GSERIAL_NO_PORTS 4
8303+
8304+static struct acm_port_info {
8305+ enum transport_type transport;
8306+ unsigned port_num;
8307+ unsigned char client_port_num;
8308+} gacm_ports[GSERIAL_NO_PORTS];
8309+
8310 static inline struct f_acm *func_to_acm(struct usb_function *f)
8311 {
8312 return container_of(f, struct f_acm, port.func);
8313@@ -87,6 +101,87 @@ static inline struct f_acm *port_to_acm(struct gserial *p)
8314 return container_of(p, struct f_acm, port);
8315 }
8316
8317+int acm_port_setup(struct usb_configuration *c)
8318+{
8319+ int ret = 0, i;
8320+
8321+ pr_debug("%s: no_acm_tty_ports:%u nr_acm_ports:%u\n",
8322+ __func__, no_acm_tty_ports, nr_acm_ports);
8323+
8324+ if (no_acm_tty_ports) {
8325+ for (i = 0; i < no_acm_tty_ports; i++) {
8326+ ret = gserial_alloc_line(
8327+ &gacm_ports[i].client_port_num);
8328+ if (ret)
8329+ return ret;
8330+ }
8331+ }
8332+ if (no_acm_smd_ports)
8333+ ret = gsmd_setup(c->cdev->gadget, no_acm_smd_ports);
8334+
8335+ return ret;
8336+}
8337+
8338+void acm_port_cleanup(void)
8339+{
8340+ int i;
8341+
8342+ for (i = 0; i < no_acm_tty_ports; i++)
8343+ gserial_free_line(gacm_ports[i].client_port_num);
8344+}
8345+
8346+static int acm_port_connect(struct f_acm *acm)
8347+{
8348+ unsigned port_num;
8349+
8350+ port_num = gacm_ports[acm->port_num].client_port_num;
8351+
8352+
8353+ pr_debug("%s: transport:%s f_acm:%p gserial:%p port_num:%d cl_port_no:%d\n",
8354+ __func__, xport_to_str(acm->transport),
8355+ acm, &acm->port, acm->port_num, port_num);
8356+
8357+ switch (acm->transport) {
8358+ case USB_GADGET_XPORT_TTY:
8359+ gserial_connect(&acm->port, port_num);
8360+ break;
8361+ case USB_GADGET_XPORT_SMD:
8362+ gsmd_connect(&acm->port, port_num);
8363+ break;
8364+ default:
8365+ pr_err("%s: Un-supported transport: %s\n", __func__,
8366+ xport_to_str(acm->transport));
8367+ return -ENODEV;
8368+ }
8369+
8370+ return 0;
8371+}
8372+
8373+static int acm_port_disconnect(struct f_acm *acm)
8374+{
8375+ unsigned port_num;
8376+
8377+ port_num = gacm_ports[acm->port_num].client_port_num;
8378+
8379+ pr_debug("%s: transport:%s f_acm:%p gserial:%p port_num:%d cl_pno:%d\n",
8380+ __func__, xport_to_str(acm->transport),
8381+ acm, &acm->port, acm->port_num, port_num);
8382+
8383+ switch (acm->transport) {
8384+ case USB_GADGET_XPORT_TTY:
8385+ gserial_disconnect(&acm->port);
8386+ break;
8387+ case USB_GADGET_XPORT_SMD:
8388+ gsmd_disconnect(&acm->port, port_num);
8389+ break;
8390+ default:
8391+ pr_err("%s: Un-supported transport:%s\n", __func__,
8392+ xport_to_str(acm->transport));
8393+ return -ENODEV;
8394+ }
8395+
8396+ return 0;
8397+}
8398 /*-------------------------------------------------------------------------*/
8399
8400 /* notification endpoint uses smallish and infrequent fixed-size messages */
8401@@ -300,23 +395,6 @@ static struct usb_gadget_strings *acm_strings[] = {
8402 NULL,
8403 };
8404
8405-#ifdef CONFIG_BRCM_FUSE_LOG
8406-
8407-/**
8408-* This function is called to register the callback functions for logging modules.
8409-*
8410-* @return 1: ready to send to logging data; 0: not ready to send the logging data.
8411-*
8412-*/
8413-char acm_logging_register_callbacks(struct acm_logging_callbacks *_cb)
8414-{
8415- pr_info("%s\n", __func__);
8416- acm_logging_cb = _cb;
8417- return 0; /* logging is not ready to send */
8418-}
8419-EXPORT_SYMBOL(acm_logging_register_callbacks);
8420-#endif
8421-
8422 /*-------------------------------------------------------------------------*/
8423
8424 /* ACM control ... data handling is delegated to tty library code.
8425@@ -412,6 +490,12 @@ static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
8426 * that bit, we should return to that no-flow state.
8427 */
8428 acm->port_handshake_bits = w_value;
8429+ if (acm->port.notify_modem) {
8430+ unsigned port_num =
8431+ gacm_ports[acm->port_num].client_port_num;
8432+
8433+ acm->port.notify_modem(&acm->port, port_num, w_value);
8434+ }
8435 break;
8436
8437 default:
8438@@ -460,7 +544,7 @@ static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
8439 } else if (intf == acm->data_id) {
8440 if (acm->port.in->driver_data) {
8441 DBG(cdev, "reset acm ttyGS%d\n", acm->port_num);
8442- gserial_disconnect(&acm->port);
8443+ acm_port_disconnect(acm);
8444 }
8445 if (!acm->port.in->desc || !acm->port.out->desc) {
8446 DBG(cdev, "activate acm ttyGS%d\n", acm->port_num);
8447@@ -473,7 +557,7 @@ static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
8448 return -EINVAL;
8449 }
8450 }
8451- gserial_connect(&acm->port, acm->port_num);
8452+ acm_port_connect(acm);
8453
8454 } else
8455 return -EINVAL;
8456@@ -487,7 +571,7 @@ static void acm_disable(struct usb_function *f)
8457 struct usb_composite_dev *cdev = f->config->cdev;
8458
8459 DBG(cdev, "acm ttyGS%d deactivated\n", acm->port_num);
8460- gserial_disconnect(&acm->port);
8461+ acm_port_disconnect(acm);
8462 usb_ep_disable(acm->notify);
8463 acm->notify->driver_data = NULL;
8464 }
8465@@ -592,30 +676,14 @@ static void acm_connect(struct gserial *port)
8466 {
8467 struct f_acm *acm = port_to_acm(port);
8468
8469- pr_info("%s", __func__);
8470-
8471 acm->serial_state |= ACM_CTRL_DSR | ACM_CTRL_DCD;
8472 acm_notify_serial_state(acm);
8473-
8474-#ifdef CONFIG_BRCM_FUSE_LOG
8475- if (acm->port_num == ACM_LOGGING_PORT)
8476- if (acm_logging_cb->start)
8477- acm_logging_cb->start();
8478-#endif
8479 }
8480
8481 static void acm_disconnect(struct gserial *port)
8482 {
8483 struct f_acm *acm = port_to_acm(port);
8484
8485- pr_info("%s", __func__);
8486-
8487-#ifdef CONFIG_BRCM_FUSE_LOG
8488- if (acm->port_num == ACM_LOGGING_PORT)
8489- if (acm_logging_cb->stop)
8490- acm_logging_cb->stop();
8491-#endif
8492-
8493 acm->serial_state &= ~(ACM_CTRL_DSR | ACM_CTRL_DCD);
8494 acm_notify_serial_state(acm);
8495 }
8496@@ -634,6 +702,15 @@ static int acm_send_break(struct gserial *port, int duration)
8497 return acm_notify_serial_state(acm);
8498 }
8499
8500+static int acm_send_modem_ctrl_bits(struct gserial *port, int ctrl_bits)
8501+{
8502+ struct f_acm *acm = port_to_acm(port);
8503+
8504+ acm->serial_state = ctrl_bits;
8505+
8506+ return acm_notify_serial_state(acm);
8507+}
8508+
8509 /*-------------------------------------------------------------------------*/
8510
8511 /* ACM function driver setup/binding */
8512@@ -732,9 +809,6 @@ acm_bind(struct usb_configuration *c, struct usb_function *f)
8513 gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
8514 acm->port.in->name, acm->port.out->name,
8515 acm->notify->name);
8516-#ifdef CONFIG_BRCM_FUSE_LOG
8517- acm_logging_cb = get_acm_callback_func();
8518-#endif
8519 return 0;
8520
8521 fail:
8522@@ -769,6 +843,7 @@ static void acm_free_func(struct usb_function *f)
8523 struct f_acm *acm = func_to_acm(f);
8524
8525 kfree(acm);
8526+ acm_next_free_port--;
8527 }
8528
8529 static struct usb_function *acm_alloc_func(struct usb_function_instance *fi)
8530@@ -780,11 +855,18 @@ static struct usb_function *acm_alloc_func(struct usb_function_instance *fi)
8531 if (!acm)
8532 return ERR_PTR(-ENOMEM);
8533
8534+ opts = container_of(fi, struct f_serial_opts, func_inst);
8535+
8536 spin_lock_init(&acm->lock);
8537
8538+ if (nr_acm_ports)
8539+ opts->port_num = acm_next_free_port++;
8540+
8541+ acm->transport = gacm_ports[opts->port_num].transport;
8542 acm->port.connect = acm_connect;
8543 acm->port.disconnect = acm_disconnect;
8544 acm->port.send_break = acm_send_break;
8545+ acm->port.send_modem_ctrl_bits = acm_send_modem_ctrl_bits;
8546
8547 acm->port.func.name = "acm";
8548 acm->port.func.strings = acm_strings;
8549@@ -794,7 +876,6 @@ static struct usb_function *acm_alloc_func(struct usb_function_instance *fi)
8550 acm->port.func.setup = acm_setup;
8551 acm->port.func.disable = acm_disable;
8552
8553- opts = container_of(fi, struct f_serial_opts, func_inst);
8554 acm->port_num = opts->port_num;
8555 acm->port.func.unbind = acm_unbind;
8556 acm->port.func.free_func = acm_free_func;
8557@@ -860,7 +941,9 @@ static void acm_free_instance(struct usb_function_instance *fi)
8558 struct f_serial_opts *opts;
8559
8560 opts = container_of(fi, struct f_serial_opts, func_inst);
8561- gserial_free_line(opts->port_num);
8562+ if (!nr_acm_ports)
8563+ gserial_free_line(opts->port_num);
8564+
8565 kfree(opts);
8566 }
8567
8568@@ -873,10 +956,12 @@ static struct usb_function_instance *acm_alloc_instance(void)
8569 if (!opts)
8570 return ERR_PTR(-ENOMEM);
8571 opts->func_inst.free_func_inst = acm_free_instance;
8572- ret = gserial_alloc_line(&opts->port_num);
8573- if (ret) {
8574- kfree(opts);
8575- return ERR_PTR(ret);
8576+ if (!nr_acm_ports) {
8577+ ret = gserial_alloc_line(&opts->port_num);
8578+ if (ret) {
8579+ kfree(opts);
8580+ return ERR_PTR(ret);
8581+ }
8582 }
8583 config_group_init_type_name(&opts->func_inst.group, "",
8584 &acm_func_type);
8585@@ -884,3 +969,39 @@ static struct usb_function_instance *acm_alloc_instance(void)
8586 }
8587 DECLARE_USB_FUNCTION_INIT(acm, acm_alloc_instance, acm_alloc_func);
8588 MODULE_LICENSE("GPL");
8589+
8590+/**
8591+ * acm_init_port - bind a acm_port to its transport
8592+ */
8593+int acm_init_port(int port_num, const char *name)
8594+{
8595+ enum transport_type transport;
8596+
8597+ if (port_num >= GSERIAL_NO_PORTS)
8598+ return -ENODEV;
8599+
8600+ transport = str_to_xport(name);
8601+ pr_debug("%s, port:%d, transport:%s\n", __func__,
8602+ port_num, xport_to_str(transport));
8603+
8604+ gacm_ports[port_num].transport = transport;
8605+ gacm_ports[port_num].port_num = port_num;
8606+
8607+ switch (transport) {
8608+ case USB_GADGET_XPORT_TTY:
8609+ no_acm_tty_ports++;
8610+ break;
8611+ case USB_GADGET_XPORT_SMD:
8612+ gacm_ports[port_num].client_port_num = no_acm_smd_ports;
8613+ no_acm_smd_ports++;
8614+ break;
8615+ default:
8616+ pr_err("%s: Un-supported transport transport: %u\n",
8617+ __func__, gacm_ports[port_num].transport);
8618+ return -ENODEV;
8619+ }
8620+
8621+ nr_acm_ports++;
8622+
8623+ return 0;
8624+}
8625diff --git a/drivers/usb/gadget/f_hid.c b/drivers/usb/gadget/f_hid.c
8626index bb9fb5e..6e69a8e 100644
8627--- a/drivers/usb/gadget/f_hid.c
8628+++ b/drivers/usb/gadget/f_hid.c
8629@@ -560,7 +560,7 @@ const struct file_operations f_hidg_fops = {
8630 .llseek = noop_llseek,
8631 };
8632
8633-static int /*__init*/ hidg_bind(struct usb_configuration *c, struct usb_function *f)
8634+static int __init hidg_bind(struct usb_configuration *c, struct usb_function *f)
8635 {
8636 struct usb_ep *ep;
8637 struct f_hidg *hidg = func_to_hidg(f);
8638@@ -689,7 +689,7 @@ static struct usb_gadget_strings *ct_func_strings[] = {
8639 /*-------------------------------------------------------------------------*/
8640 /* usb_configuration */
8641
8642-int /*__init*/ hidg_bind_config(struct usb_configuration *c,
8643+int __init hidg_bind_config(struct usb_configuration *c,
8644 struct hidg_func_descriptor *fdesc, int index)
8645 {
8646 struct f_hidg *hidg;
8647@@ -743,7 +743,7 @@ int /*__init*/ hidg_bind_config(struct usb_configuration *c,
8648 return status;
8649 }
8650
8651-int ghid_setup(struct usb_gadget *g, int count)
8652+int __init ghid_setup(struct usb_gadget *g, int count)
8653 {
8654 int status;
8655 dev_t dev;
8656diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
8657index 9f2987d..aad3b7d 100644
8658--- a/drivers/usb/gadget/f_mass_storage.c
8659+++ b/drivers/usb/gadget/f_mass_storage.c
8660@@ -230,7 +230,11 @@ static const char fsg_string_interface[] = "Mass Storage";
8661
8662 #include "storage_common.c"
8663
8664-
8665+#ifdef CONFIG_USB_CSW_HACK
8666+static int write_error_after_csw_sent;
8667+static int must_report_residue;
8668+static int csw_hack_sent;
8669+#endif
8670 /*-------------------------------------------------------------------------*/
8671
8672 struct fsg_dev;
8673@@ -369,6 +373,7 @@ static inline struct fsg_dev *fsg_from_func(struct usb_function *f)
8674 }
8675
8676 typedef void (*fsg_routine_t)(struct fsg_dev *);
8677+static int send_status(struct fsg_common *common);
8678
8679 static int exception_in_progress(struct fsg_common *common)
8680 {
8681@@ -536,7 +541,10 @@ static int fsg_setup(struct usb_function *f,
8682 */
8683 DBG(fsg, "bulk reset request\n");
8684 raise_exception(fsg->common, FSG_STATE_RESET);
8685- return DELAYED_STATUS;
8686+ if (fsg->common->cdev)
8687+ return USB_GADGET_DELAYED_STATUS;
8688+ else
8689+ return DELAYED_STATUS;
8690
8691 case US_BULK_GET_MAX_LUN:
8692 if (ctrl->bRequestType !=
8693@@ -627,12 +635,18 @@ static int sleep_thread(struct fsg_common *common)
8694 rc = -EINTR;
8695 break;
8696 }
8697- if (common->thread_wakeup_needed)
8698+ spin_lock_irq(&common->lock);
8699+ if (common->thread_wakeup_needed) {
8700+ spin_unlock_irq(&common->lock);
8701 break;
8702+ }
8703+ spin_unlock_irq(&common->lock);
8704 schedule();
8705 }
8706 __set_current_state(TASK_RUNNING);
8707+ spin_lock_irq(&common->lock);
8708 common->thread_wakeup_needed = 0;
8709+ spin_unlock_irq(&common->lock);
8710 smp_rmb(); /* ensure the latest bh->state is visible */
8711 return rc;
8712 }
8713@@ -696,12 +710,17 @@ static int do_read(struct fsg_common *common)
8714 curlun->file_length - file_offset);
8715
8716 /* Wait for the next buffer to become available */
8717+ spin_lock_irq(&common->lock);
8718 bh = common->next_buffhd_to_fill;
8719 while (bh->state != BUF_STATE_EMPTY) {
8720+ spin_unlock_irq(&common->lock);
8721 rc = sleep_thread(common);
8722 if (rc)
8723 return rc;
8724+
8725+ spin_lock_irq(&common->lock);
8726 }
8727+ spin_unlock_irq(&common->lock);
8728
8729 /*
8730 * If we were asked to read past the end of file,
8731@@ -713,8 +732,10 @@ static int do_read(struct fsg_common *common)
8732 curlun->sense_data_info =
8733 file_offset >> curlun->blkbits;
8734 curlun->info_valid = 1;
8735+ spin_lock_irq(&common->lock);
8736 bh->inreq->length = 0;
8737 bh->state = BUF_STATE_FULL;
8738+ spin_unlock_irq(&common->lock);
8739 break;
8740 }
8741
8742@@ -754,8 +775,10 @@ static int do_read(struct fsg_common *common)
8743 * equal to the buffer size, which is divisible by the
8744 * bulk-in maxpacket size.
8745 */
8746+ spin_lock_irq(&common->lock);
8747 bh->inreq->length = nread;
8748 bh->state = BUF_STATE_FULL;
8749+ spin_unlock_irq(&common->lock);
8750
8751 /* If an error occurred, report it and its position */
8752 if (nread < amount) {
8753@@ -795,6 +818,9 @@ static int do_write(struct fsg_common *common)
8754 ssize_t nwritten;
8755 int rc;
8756
8757+#ifdef CONFIG_USB_CSW_HACK
8758+ int i;
8759+#endif
8760
8761 #ifdef CONFIG_USB_MSC_PROFILING
8762 ktime_t start, diff;
8763@@ -891,7 +917,17 @@ static int do_write(struct fsg_common *common)
8764 bh = common->next_buffhd_to_drain;
8765 if (bh->state == BUF_STATE_EMPTY && !get_some_more)
8766 break; /* We stopped early */
8767+#ifdef CONFIG_USB_CSW_HACK
8768+ /*
8769+ * If the csw packet is already submmitted to the hardware,
8770+ * by marking the state of buffer as full, then by checking
8771+ * the residue, we make sure that this csw packet is not
8772+ * written on to the storage media.
8773+ */
8774+ if (bh->state == BUF_STATE_FULL && common->residue) {
8775+#else
8776 if (bh->state == BUF_STATE_FULL) {
8777+#endif
8778 smp_rmb();
8779 common->next_buffhd_to_drain = bh->next;
8780 bh->state = BUF_STATE_EMPTY;
8781@@ -962,9 +998,47 @@ static int do_write(struct fsg_common *common)
8782 curlun->sense_data_info =
8783 file_offset >> curlun->blkbits;
8784 curlun->info_valid = 1;
8785+#ifdef CONFIG_USB_CSW_HACK
8786+ write_error_after_csw_sent = 1;
8787+ goto write_error;
8788+#endif
8789 break;
8790 }
8791
8792+#ifdef CONFIG_USB_CSW_HACK
8793+write_error:
8794+ if ((nwritten == amount) && !csw_hack_sent) {
8795+ if (write_error_after_csw_sent)
8796+ break;
8797+
8798+ /*
8799+ * If residue still exists and nothing left to
8800+ * write, device must send correct residue to
8801+ * host in this case.
8802+ */
8803+ if (!amount_left_to_write && common->residue) {
8804+ must_report_residue = 1;
8805+ break;
8806+ }
8807+ /*
8808+ * Check if any of the buffer is in the
8809+ * busy state, if any buffer is in busy state,
8810+ * means the complete data is not received
8811+ * yet from the host. So there is no point in
8812+ * csw right away without the complete data.
8813+ */
8814+ for (i = 0; i < fsg_num_buffers; i++) {
8815+ if (common->buffhds[i].state ==
8816+ BUF_STATE_BUSY)
8817+ break;
8818+ }
8819+ if (!amount_left_to_req && i == fsg_num_buffers) {
8820+ csw_hack_sent = 1;
8821+ send_status(common);
8822+ }
8823+ }
8824+#endif
8825+
8826 empty_write:
8827 /* Did the host decide to stop early? */
8828 if (bh->outreq->actual < bh->bulk_out_intended_length) {
8829@@ -1413,8 +1487,7 @@ static int do_prevent_allow(struct fsg_common *common)
8830 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
8831 return -EINVAL;
8832 }
8833-
8834- if (curlun->prevent_medium_removal && !prevent)
8835+ if (!curlun->nofua && curlun->prevent_medium_removal && !prevent)
8836 fsg_lun_fsync_sub(curlun);
8837 curlun->prevent_medium_removal = prevent;
8838 return 0;
8839@@ -1661,12 +1734,17 @@ static int send_status(struct fsg_common *common)
8840 u32 sd, sdinfo = 0;
8841
8842 /* Wait for the next buffer to become available */
8843+ spin_lock_irq(&common->lock);
8844 bh = common->next_buffhd_to_fill;
8845 while (bh->state != BUF_STATE_EMPTY) {
8846+ spin_unlock_irq(&common->lock);
8847 rc = sleep_thread(common);
8848 if (rc)
8849 return rc;
8850+
8851+ spin_lock_irq(&common->lock);
8852 }
8853+ spin_unlock_irq(&common->lock);
8854
8855 if (curlun) {
8856 sd = curlun->sense_data;
8857@@ -1694,6 +1772,20 @@ static int send_status(struct fsg_common *common)
8858 csw->Signature = cpu_to_le32(US_BULK_CS_SIGN);
8859 csw->Tag = common->tag;
8860 csw->Residue = cpu_to_le32(common->residue);
8861+#ifdef CONFIG_USB_CSW_HACK
8862+ /* Since csw is being sent early, before
8863+ * writing on to storage media, need to set
8864+ * residue to zero,assuming that write will succeed.
8865+ */
8866+ if (write_error_after_csw_sent || must_report_residue) {
8867+ write_error_after_csw_sent = 0;
8868+ must_report_residue = 0;
8869+ csw->Residue = cpu_to_le32(common->residue);
8870+ } else
8871+ csw->Residue = 0;
8872+#else
8873+ csw->Residue = cpu_to_le32(common->residue);
8874+#endif
8875 csw->Status = status;
8876
8877 bh->inreq->length = US_BULK_CS_WRAP_LEN;
8878@@ -1863,13 +1955,19 @@ static int do_scsi_command(struct fsg_common *common)
8879 dump_cdb(common);
8880
8881 /* Wait for the next buffer to become available for data or status */
8882+ spin_lock_irq(&common->lock);
8883 bh = common->next_buffhd_to_fill;
8884 common->next_buffhd_to_drain = bh;
8885 while (bh->state != BUF_STATE_EMPTY) {
8886+ spin_unlock_irq(&common->lock);
8887 rc = sleep_thread(common);
8888 if (rc)
8889 return rc;
8890+
8891+ spin_lock_irq(&common->lock);
8892 }
8893+ spin_unlock_irq(&common->lock);
8894+
8895 common->phase_error = 0;
8896 common->short_packet_received = 0;
8897
8898@@ -2210,12 +2308,17 @@ static int get_next_command(struct fsg_common *common)
8899 int rc = 0;
8900
8901 /* Wait for the next buffer to become available */
8902+ spin_lock_irq(&common->lock);
8903 bh = common->next_buffhd_to_fill;
8904 while (bh->state != BUF_STATE_EMPTY) {
8905+ spin_unlock_irq(&common->lock);
8906 rc = sleep_thread(common);
8907 if (rc)
8908 return rc;
8909+
8910+ spin_lock_irq(&common->lock);
8911 }
8912+ spin_unlock_irq(&common->lock);
8913
8914 /* Queue a request to read a Bulk-only CBW */
8915 set_bulk_out_req_length(common, bh, US_BULK_CB_WRAP_LEN);
8916@@ -2230,14 +2333,23 @@ static int get_next_command(struct fsg_common *common)
8917 */
8918
8919 /* Wait for the CBW to arrive */
8920+ spin_lock_irq(&common->lock);
8921 while (bh->state != BUF_STATE_FULL) {
8922+ spin_unlock_irq(&common->lock);
8923 rc = sleep_thread(common);
8924 if (rc)
8925 return rc;
8926+
8927+ spin_lock_irq(&common->lock);
8928 }
8929+ spin_unlock_irq(&common->lock);
8930+
8931 smp_rmb();
8932 rc = fsg_is_set(common) ? received_cbw(common->fsg, bh) : -EIO;
8933+
8934+ spin_lock_irq(&common->lock);
8935 bh->state = BUF_STATE_EMPTY;
8936+ spin_unlock_irq(&common->lock);
8937
8938 return rc;
8939 }
8940@@ -2282,15 +2394,6 @@ reset:
8941 }
8942 }
8943
8944- /* Disable the endpoints */
8945- if (fsg->bulk_in_enabled) {
8946- usb_ep_disable(fsg->bulk_in);
8947- fsg->bulk_in_enabled = 0;
8948- }
8949- if (fsg->bulk_out_enabled) {
8950- usb_ep_disable(fsg->bulk_out);
8951- fsg->bulk_out_enabled = 0;
8952- }
8953
8954 common->fsg = NULL;
8955 wake_up(&common->fsg_wait);
8956@@ -2303,28 +2406,6 @@ reset:
8957 common->fsg = new_fsg;
8958 fsg = common->fsg;
8959
8960- /* Enable the endpoints */
8961- rc = config_ep_by_speed(common->gadget, &(fsg->function), fsg->bulk_in);
8962- if (rc)
8963- goto reset;
8964- rc = usb_ep_enable(fsg->bulk_in);
8965- if (rc)
8966- goto reset;
8967- fsg->bulk_in->driver_data = common;
8968- fsg->bulk_in_enabled = 1;
8969-
8970- rc = config_ep_by_speed(common->gadget, &(fsg->function),
8971- fsg->bulk_out);
8972- if (rc)
8973- goto reset;
8974- rc = usb_ep_enable(fsg->bulk_out);
8975- if (rc)
8976- goto reset;
8977- fsg->bulk_out->driver_data = common;
8978- fsg->bulk_out_enabled = 1;
8979- common->bulk_out_maxpacket = usb_endpoint_maxp(fsg->bulk_out->desc);
8980- clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
8981-
8982 /* Allocate the requests */
8983 for (i = 0; i < fsg_num_buffers; ++i) {
8984 struct fsg_buffhd *bh = &common->buffhds[i];
8985@@ -2353,14 +2434,58 @@ reset:
8986 static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
8987 {
8988 struct fsg_dev *fsg = fsg_from_func(f);
8989+ struct fsg_common *common = fsg->common;
8990+ int rc;
8991+
8992+ /* Enable the endpoints */
8993+ rc = config_ep_by_speed(common->gadget, &(fsg->function), fsg->bulk_in);
8994+ if (rc)
8995+ return rc;
8996+ rc = usb_ep_enable(fsg->bulk_in);
8997+ if (rc)
8998+ return rc;
8999+ fsg->bulk_in->driver_data = common;
9000+ fsg->bulk_in_enabled = 1;
9001+
9002+ rc = config_ep_by_speed(common->gadget, &(fsg->function),
9003+ fsg->bulk_out);
9004+ if (rc)
9005+ goto reset_bulk_int;
9006+ rc = usb_ep_enable(fsg->bulk_out);
9007+ if (rc)
9008+ goto reset_bulk_int;
9009+ fsg->bulk_out->driver_data = common;
9010+ fsg->bulk_out_enabled = 1;
9011+ common->bulk_out_maxpacket =
9012+ le16_to_cpu(fsg->bulk_out->desc->wMaxPacketSize);
9013+ clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
9014+ csw_hack_sent = 0;
9015+ write_error_after_csw_sent = 0;
9016 fsg->common->new_fsg = fsg;
9017 raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
9018 return USB_GADGET_DELAYED_STATUS;
9019+
9020+reset_bulk_int:
9021+ usb_ep_disable(fsg->bulk_in);
9022+ fsg->bulk_in_enabled = 0;
9023+ return rc;
9024 }
9025
9026 static void fsg_disable(struct usb_function *f)
9027 {
9028 struct fsg_dev *fsg = fsg_from_func(f);
9029+
9030+ /* Disable the endpoints */
9031+ if (fsg->bulk_in_enabled) {
9032+ usb_ep_disable(fsg->bulk_in);
9033+ fsg->bulk_in_enabled = 0;
9034+ fsg->bulk_in->driver_data = NULL;
9035+ }
9036+ if (fsg->bulk_out_enabled) {
9037+ usb_ep_disable(fsg->bulk_out);
9038+ fsg->bulk_out_enabled = 0;
9039+ fsg->bulk_out->driver_data = NULL;
9040+ }
9041 fsg->common->new_fsg = NULL;
9042 raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
9043 }
9044@@ -2407,10 +2532,13 @@ static void handle_exception(struct fsg_common *common)
9045 /* Wait until everything is idle */
9046 for (;;) {
9047 int num_active = 0;
9048+ spin_lock_irq(&common->lock);
9049 for (i = 0; i < fsg_num_buffers; ++i) {
9050 bh = &common->buffhds[i];
9051 num_active += bh->inreq_busy + bh->outreq_busy;
9052 }
9053+ spin_unlock_irq(&common->lock);
9054+
9055 if (num_active == 0)
9056 break;
9057 if (sleep_thread(common))
9058@@ -2476,8 +2604,13 @@ static void handle_exception(struct fsg_common *common)
9059 &common->fsg->atomic_bitflags))
9060 usb_ep_clear_halt(common->fsg->bulk_in);
9061
9062- if (common->ep0_req_tag == exception_req_tag)
9063- ep0_queue(common); /* Complete the status stage */
9064+ if (common->ep0_req_tag == exception_req_tag) {
9065+ /* Complete the status stage */
9066+ if (common->cdev)
9067+ usb_composite_setup_continue(common->cdev);
9068+ else
9069+ ep0_queue(common);
9070+ }
9071
9072 /*
9073 * Technically this should go here, but it would only be
9074@@ -2567,6 +2700,16 @@ static int fsg_main_thread(void *common_)
9075 common->state = FSG_STATE_STATUS_PHASE;
9076 spin_unlock_irq(&common->lock);
9077
9078+#ifdef CONFIG_USB_CSW_HACK
9079+ /* Since status is already sent for write scsi command,
9080+ * need to skip sending status once again if it is a
9081+ * write scsi command.
9082+ */
9083+ if (csw_hack_sent) {
9084+ csw_hack_sent = 0;
9085+ continue;
9086+ }
9087+#endif
9088 if (send_status(common))
9089 continue;
9090
9091@@ -2604,20 +2747,18 @@ static int fsg_main_thread(void *common_)
9092 /*************************** DEVICE ATTRIBUTES ***************************/
9093
9094 static DEVICE_ATTR(ro, 0644, fsg_show_ro, fsg_store_ro);
9095-static DEVICE_ATTR(cdrom, 0644, fsg_show_cdrom, fsg_store_cdrom);
9096 static DEVICE_ATTR(nofua, 0644, fsg_show_nofua, fsg_store_nofua);
9097 static DEVICE_ATTR(file, 0644, fsg_show_file, fsg_store_file);
9098
9099 static struct device_attribute dev_attr_ro_cdrom =
9100 __ATTR(ro, 0444, fsg_show_ro, NULL);
9101 static struct device_attribute dev_attr_file_nonremovable =
9102- __ATTR(file, 0444, fsg_show_file, NULL);
9103+ __ATTR(file, 0644, fsg_show_file, fsg_store_file);
9104
9105 #ifdef CONFIG_USB_MSC_PROFILING
9106 static DEVICE_ATTR(perf, 0644, fsg_show_perf, fsg_store_perf);
9107 #endif
9108
9109-
9110 /****************************** FSG COMMON ******************************/
9111
9112 static void fsg_common_release(struct kref *ref);
9113@@ -2637,6 +2778,95 @@ static inline void fsg_common_put(struct fsg_common *common)
9114 kref_put(&common->ref, fsg_common_release);
9115 }
9116
9117+/*
9118+ * This function creates device entry for LUN and its related paramters.
9119+*/
9120+static int create_lun_device(struct fsg_common *common,
9121+ struct usb_composite_dev *cdev,
9122+ struct fsg_config *cfg,
9123+ int add_lun_index)
9124+{
9125+ struct usb_gadget *gadget = cdev->gadget;
9126+ struct fsg_lun *curlun = common->luns;
9127+ struct fsg_lun_config *lcfg = cfg->luns;
9128+ int rc = 0, i;
9129+ int nluns = cfg->nluns;
9130+
9131+ /*
9132+ * Check if index is non-zero, increment current lun_config
9133+ * and cur_lun pointers.
9134+ */
9135+ lcfg += add_lun_index;
9136+ curlun += add_lun_index;
9137+
9138+ for (i = add_lun_index; i < nluns; ++i, ++curlun, ++lcfg) {
9139+ curlun->cdrom = !!lcfg->cdrom;
9140+ curlun->ro = lcfg->cdrom || lcfg->ro;
9141+ curlun->initially_ro = curlun->ro;
9142+ curlun->removable = lcfg->removable;
9143+ curlun->nofua = lcfg->nofua;
9144+ curlun->dev.release = fsg_lun_release;
9145+ curlun->dev.parent = &gadget->dev;
9146+ /* curlun->dev.driver = &fsg_driver.driver; XXX */
9147+ dev_set_drvdata(&curlun->dev, &common->filesem);
9148+ dev_set_name(&curlun->dev, "lun%d", i);
9149+
9150+ rc = device_register(&curlun->dev);
9151+ if (rc) {
9152+ pr_err("failed to register LUN%d: %d\n", i, rc);
9153+ common->nluns = i;
9154+ put_device(&curlun->dev);
9155+ goto error_release;
9156+ }
9157+
9158+ rc = device_create_file(&curlun->dev,
9159+ curlun->cdrom
9160+ ? &dev_attr_ro_cdrom
9161+ : &dev_attr_ro);
9162+ if (rc)
9163+ goto error_luns;
9164+
9165+ rc = device_create_file(&curlun->dev,
9166+ curlun->removable
9167+ ? &dev_attr_file
9168+ : &dev_attr_file_nonremovable);
9169+ if (rc)
9170+ goto error_luns;
9171+
9172+ rc = device_create_file(&curlun->dev, &dev_attr_nofua);
9173+ if (rc)
9174+ goto error_luns;
9175+
9176+#ifdef CONFIG_USB_MSC_PROFILING
9177+ rc = device_create_file(&curlun->dev, &dev_attr_perf);
9178+ if (rc)
9179+ pr_err("failed to create perf sysfs node:%d\n", rc);
9180+#endif
9181+ if (lcfg->filename) {
9182+ rc = fsg_lun_open(curlun, lcfg->filename);
9183+ if (rc) {
9184+ pr_err("failed to open lun file.\n");
9185+ goto error_luns;
9186+ }
9187+ } else if (!curlun->removable && !curlun->cdrom) {
9188+ ERROR(common, "no file given for LUN%d\n", i);
9189+ rc = -EINVAL;
9190+ goto error_luns;
9191+ }
9192+ }
9193+
9194+ common->nluns = nluns;
9195+ return rc;
9196+
9197+error_luns:
9198+ common->nluns = i;
9199+error_release:
9200+ common->state = FSG_STATE_TERMINATED;
9201+ fsg_common_release(&common->ref);
9202+
9203+ return rc;
9204+}
9205+
9206 static struct fsg_common *fsg_common_init(struct fsg_common *common,
9207 struct usb_composite_dev *cdev,
9208 struct fsg_config *cfg)
9209@@ -2644,7 +2874,6 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
9210 struct usb_gadget *gadget = cdev->gadget;
9211 struct fsg_buffhd *bh;
9212 struct fsg_lun *curlun;
9213- struct fsg_lun_config *lcfg;
9214 int nluns, i, rc;
9215 char *pathbuf;
9216
9217@@ -2686,20 +2915,11 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
9218 common->ep0req = cdev->req;
9219 common->cdev = cdev;
9220
9221- /* Maybe allocate device-global string IDs, and patch descriptors */
9222- if (fsg_strings[FSG_STRING_INTERFACE].id == 0) {
9223- rc = usb_string_id(cdev);
9224- if (unlikely(rc < 0))
9225- goto error_release;
9226- fsg_strings[FSG_STRING_INTERFACE].id = rc;
9227- fsg_intf_desc.iInterface = rc;
9228- }
9229-
9230 /*
9231 * Create the LUNs, open their backing files, and register the
9232 * LUN devices in sysfs.
9233 */
9234- curlun = kcalloc(nluns, sizeof(*curlun), GFP_KERNEL);
9235+ curlun = kcalloc(FSG_MAX_LUNS, sizeof(*curlun), GFP_KERNEL);
9236 if (unlikely(!curlun)) {
9237 rc = -ENOMEM;
9238 goto error_release;
9239@@ -2707,63 +2927,9 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
9240 common->luns = curlun;
9241
9242 init_rwsem(&common->filesem);
9243-
9244- for (i = 0, lcfg = cfg->luns; i < nluns; ++i, ++curlun, ++lcfg) {
9245- curlun->cdrom = !!lcfg->cdrom;
9246- curlun->ro = lcfg->cdrom || lcfg->ro;
9247- curlun->initially_ro = curlun->ro;
9248- curlun->removable = lcfg->removable;
9249- curlun->dev.release = fsg_lun_release;
9250- curlun->dev.parent = &gadget->dev;
9251- /* curlun->dev.driver = &fsg_driver.driver; XXX */
9252- dev_set_drvdata(&curlun->dev, &common->filesem);
9253- dev_set_name(&curlun->dev, "lun%d", i);
9254-
9255- rc = device_register(&curlun->dev);
9256- if (rc) {
9257- INFO(common, "failed to register LUN%d: %d\n", i, rc);
9258- common->nluns = i;
9259- put_device(&curlun->dev);
9260- goto error_release;
9261- }
9262-
9263- rc = device_create_file(&curlun->dev,
9264- curlun->cdrom
9265- ? &dev_attr_ro_cdrom
9266- : &dev_attr_ro);
9267- if (rc)
9268- goto error_luns;
9269- rc = device_create_file(&curlun->dev,
9270- curlun->removable
9271- ? &dev_attr_file
9272- : &dev_attr_file_nonremovable);
9273- if (rc)
9274- goto error_luns;
9275-
9276- rc = device_create_file(&curlun->dev, &dev_attr_cdrom);
9277- if (rc)
9278- goto error_luns;
9279-
9280- rc = device_create_file(&curlun->dev, &dev_attr_nofua);
9281- if (rc)
9282- goto error_luns;
9283-#ifdef CONFIG_USB_MSC_PROFILING
9284- rc = device_create_file(&curlun->dev, &dev_attr_perf);
9285- if (rc)
9286- dev_err(&gadget->dev, "failed to create sysfs entry:"
9287- "(dev_attr_perf) error: %d\n", rc);
9288-#endif
9289- if (lcfg->filename) {
9290- rc = fsg_lun_open(curlun, lcfg->filename);
9291- if (rc)
9292- goto error_luns;
9293- } else if (!curlun->removable) {
9294- ERROR(common, "no file given for LUN%d\n", i);
9295- rc = -EINVAL;
9296- goto error_luns;
9297- }
9298- }
9299- common->nluns = nluns;
9300+ rc = create_lun_device(common, cdev, cfg, 0);
9301+ if (rc != 0)
9302+ goto error;
9303
9304 /* Data buffers cyclic list */
9305 bh = common->buffhds;
9306@@ -2844,12 +3010,11 @@ buffhds_first_it:
9307
9308 return common;
9309
9310-error_luns:
9311- common->nluns = i + 1;
9312 error_release:
9313 common->state = FSG_STATE_TERMINATED; /* The thread is dead */
9314 /* Call fsg_common_release() directly, ref might be not initialised. */
9315 fsg_common_release(&common->ref);
9316+error:
9317 return ERR_PTR(rc);
9318 }
9319
9320@@ -2873,7 +3038,6 @@ static void fsg_common_release(struct kref *ref)
9321 device_remove_file(&lun->dev, &dev_attr_perf);
9322 #endif
9323 device_remove_file(&lun->dev, &dev_attr_nofua);
9324-
9325 device_remove_file(&lun->dev,
9326 lun->cdrom
9327 ? &dev_attr_ro_cdrom
9328@@ -2882,7 +3046,6 @@ static void fsg_common_release(struct kref *ref)
9329 lun->removable
9330 ? &dev_attr_file
9331 : &dev_attr_file_nonremovable);
9332- device_remove_file(&lun->dev, &dev_attr_cdrom);
9333 fsg_lun_close(lun);
9334 device_unregister(&lun->dev);
9335 }
9336@@ -2998,6 +3161,15 @@ static int fsg_bind_config(struct usb_composite_dev *cdev,
9337 struct fsg_dev *fsg;
9338 int rc;
9339
9340+ /* Maybe allocate device-global string IDs, and patch descriptors */
9341+ if (fsg_strings[FSG_STRING_INTERFACE].id == 0) {
9342+ rc = usb_string_id(cdev);
9343+ if (unlikely(rc < 0))
9344+ return rc;
9345+ fsg_strings[FSG_STRING_INTERFACE].id = rc;
9346+ fsg_intf_desc.iInterface = rc;
9347+ }
9348+
9349 fsg = kzalloc(sizeof *fsg, GFP_KERNEL);
9350 if (unlikely(!fsg))
9351 return -ENOMEM;
9352@@ -3116,3 +3288,27 @@ fsg_common_from_params(struct fsg_common *common,
9353 fsg_config_from_params(&cfg, params);
9354 return fsg_common_init(common, cdev, &cfg);
9355 }
9356+
9357+/*
9358+ * This API allows to add luns devices when MSC is being enabled.
9359+ */
9360+static int fsg_add_lun(struct fsg_common *common,
9361+ struct usb_composite_dev *cdev,
9362+ struct fsg_config *cfg,
9363+ int add_luns)
9364+{
9365+ int nluns, rc = 0;
9366+ int total_luns;
9367+
9368+ if (add_luns) {
9369+ nluns = common->nluns;
9370+ total_luns = nluns + add_luns;
9371+ pr_debug("total_luns:%d\n", total_luns);
9372+ cfg->nluns = total_luns;
9373+ rc = create_lun_device(common, cdev, cfg, nluns);
9374+ if (rc)
9375+ pr_err("Failed device lun creation.\n");
9376+ }
9377+
9378+ return rc;
9379+}
9380diff --git a/drivers/usb/gadget/f_ncm.c b/drivers/usb/gadget/f_ncm.c
9381index 2769688..3c847cf 100644
9382--- a/drivers/usb/gadget/f_ncm.c
9383+++ b/drivers/usb/gadget/f_ncm.c
9384@@ -24,6 +24,21 @@
9385
9386 #include "u_ether.h"
9387
9388+#undef DBG
9389+#undef VDBG
9390+#undef ERROR
9391+#undef INFO
9392+
9393+#define DBG(d, fmt, args...) \
9394+ dev_dbg(&(d)->gadget->dev , fmt , ## args)
9395+#define VDBG(d, fmt, args...) \
9396+ dev_vdbg(&(d)->gadget->dev , fmt , ## args)
9397+#define ERROR(d, fmt, args...) \
9398+ dev_err(&(d)->gadget->dev , fmt , ## args)
9399+#define WARNING(d, fmt, args...) \
9400+ dev_warn(&(d)->gadget->dev , fmt , ## args)
9401+#define INFO(d, fmt, args...) \
9402+ dev_info(&(d)->gadget->dev , fmt , ## args)
9403 /*
9404 * This function is a "CDC Network Control Model" (CDC NCM) Ethernet link.
9405 * NCM is intended to be used with high-speed network attachments.
9406@@ -167,8 +182,8 @@ static struct usb_cdc_union_desc ncm_union_desc = {
9407 /* .bSlaveInterface0 = DYNAMIC */
9408 };
9409
9410-static struct usb_cdc_ether_desc ecm_desc = {
9411- .bLength = sizeof ecm_desc,
9412+static struct usb_cdc_ether_desc necm_desc = {
9413+ .bLength = sizeof necm_desc,
9414 .bDescriptorType = USB_DT_CS_INTERFACE,
9415 .bDescriptorSubType = USB_CDC_ETHERNET_TYPE,
9416
9417@@ -256,7 +271,7 @@ static struct usb_descriptor_header *ncm_fs_function[] = {
9418 (struct usb_descriptor_header *) &ncm_control_intf,
9419 (struct usb_descriptor_header *) &ncm_header_desc,
9420 (struct usb_descriptor_header *) &ncm_union_desc,
9421- (struct usb_descriptor_header *) &ecm_desc,
9422+ (struct usb_descriptor_header *) &necm_desc,
9423 (struct usb_descriptor_header *) &ncm_desc,
9424 (struct usb_descriptor_header *) &fs_ncm_notify_desc,
9425 /* data interface, altsettings 0 and 1 */
9426@@ -302,7 +317,7 @@ static struct usb_descriptor_header *ncm_hs_function[] = {
9427 (struct usb_descriptor_header *) &ncm_control_intf,
9428 (struct usb_descriptor_header *) &ncm_header_desc,
9429 (struct usb_descriptor_header *) &ncm_union_desc,
9430- (struct usb_descriptor_header *) &ecm_desc,
9431+ (struct usb_descriptor_header *) &necm_desc,
9432 (struct usb_descriptor_header *) &ncm_desc,
9433 (struct usb_descriptor_header *) &hs_ncm_notify_desc,
9434 /* data interface, altsettings 0 and 1 */
9435@@ -313,17 +328,88 @@ static struct usb_descriptor_header *ncm_hs_function[] = {
9436 NULL,
9437 };
9438
9439+/* Super Speed Support */
9440+static struct usb_endpoint_descriptor ncm_ss_notify_desc = {
9441+ .bLength = USB_DT_ENDPOINT_SIZE,
9442+ .bDescriptorType = USB_DT_ENDPOINT,
9443+ .bEndpointAddress = USB_DIR_IN,
9444+ .bmAttributes = USB_ENDPOINT_XFER_INT,
9445+ .wMaxPacketSize = cpu_to_le16(NCM_STATUS_BYTECOUNT),
9446+ .bInterval = USB_MS_TO_HS_INTERVAL(NCM_STATUS_INTERVAL_MS),
9447+};
9448+
9449+static struct usb_ss_ep_comp_descriptor ncm_ss_notify_comp_desc = {
9450+ .bLength = sizeof(ncm_ss_notify_comp_desc),
9451+ .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
9452+ /* the following 3 values can be tweaked if necessary */
9453+ /* .bMaxBurst = 0, */
9454+ /* .bmAttributes = 0, */
9455+ .wBytesPerInterval = cpu_to_le16(NCM_STATUS_BYTECOUNT),
9456+};
9457+
9458+static struct usb_endpoint_descriptor ncm_ss_in_desc = {
9459+ .bLength = USB_DT_ENDPOINT_SIZE,
9460+ .bDescriptorType = USB_DT_ENDPOINT,
9461+ .bEndpointAddress = USB_DIR_IN,
9462+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
9463+ .wMaxPacketSize = cpu_to_le16(1024),
9464+};
9465+
9466+static struct usb_ss_ep_comp_descriptor ncm_ss_in_comp_desc = {
9467+ .bLength = sizeof(ncm_ss_in_comp_desc),
9468+ .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
9469+ /* the following 2 values can be tweaked if necessary */
9470+ /* .bMaxBurst = 0, */
9471+ /* .bmAttributes = 0, */
9472+};
9473+
9474+static struct usb_endpoint_descriptor ncm_ss_out_desc = {
9475+ .bLength = USB_DT_ENDPOINT_SIZE,
9476+ .bDescriptorType = USB_DT_ENDPOINT,
9477+ .bEndpointAddress = USB_DIR_OUT,
9478+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
9479+ .wMaxPacketSize = cpu_to_le16(1024),
9480+};
9481+
9482+static struct usb_ss_ep_comp_descriptor ncm_ss_out_comp_desc = {
9483+ .bLength = sizeof(ncm_ss_out_comp_desc),
9484+ .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
9485+ /* the following 2 values can be tweaked if necessary */
9486+ /* .bMaxBurst = 0, */
9487+ /* .bmAttributes = 0, */
9488+};
9489+
9490+static struct usb_descriptor_header *ncm_ss_function[] = {
9491+ (struct usb_descriptor_header *) &ncm_iad_desc,
9492+ /* CDC NCM control descriptors */
9493+ (struct usb_descriptor_header *) &ncm_control_intf,
9494+ (struct usb_descriptor_header *) &ncm_header_desc,
9495+ (struct usb_descriptor_header *) &ncm_union_desc,
9496+ (struct usb_descriptor_header *) &necm_desc,
9497+ (struct usb_descriptor_header *) &ncm_desc,
9498+ (struct usb_descriptor_header *) &ncm_ss_notify_desc,
9499+ (struct usb_descriptor_header *) &ncm_ss_notify_comp_desc,
9500+ /* data interface, altsettings 0 and 1 */
9501+ (struct usb_descriptor_header *) &ncm_data_nop_intf,
9502+ (struct usb_descriptor_header *) &ncm_data_intf,
9503+ (struct usb_descriptor_header *) &ncm_ss_in_desc,
9504+ (struct usb_descriptor_header *) &ncm_ss_in_comp_desc,
9505+ (struct usb_descriptor_header *) &ncm_ss_out_desc,
9506+ (struct usb_descriptor_header *) &ncm_ss_out_comp_desc,
9507+ NULL,
9508+};
9509+
9510 /* string descriptors: */
9511
9512 #define STRING_CTRL_IDX 0
9513 #define STRING_MAC_IDX 1
9514-#define STRING_DATA_IDX 2
9515+#define NCM_STRING_DATA_IDX 2 /* Avoid a collision with f_mbim.c */
9516 #define STRING_IAD_IDX 3
9517
9518 static struct usb_string ncm_string_defs[] = {
9519 [STRING_CTRL_IDX].s = "CDC Network Control Model (NCM)",
9520 [STRING_MAC_IDX].s = "",
9521- [STRING_DATA_IDX].s = "CDC Network Data",
9522+ [NCM_STRING_DATA_IDX].s = "CDC Network Data",
9523 [STRING_IAD_IDX].s = "CDC NCM",
9524 { } /* end of list */
9525 };
9526@@ -435,6 +521,7 @@ static inline unsigned get_ncm(__le16 **p, unsigned size)
9527 static inline void ncm_reset_values(struct f_ncm *ncm)
9528 {
9529 ncm->parser_opts = &ndp16_opts;
9530+ ncm->ndp_sign = ncm->parser_opts->ndp_sign;
9531 ncm->is_crc = false;
9532 ncm->port.cdc_filter = DEFAULT_FILTER;
9533
9534@@ -1222,8 +1309,17 @@ ncm_bind(struct usb_configuration *c, struct usb_function *f)
9535 hs_ncm_notify_desc.bEndpointAddress =
9536 fs_ncm_notify_desc.bEndpointAddress;
9537
9538+ if (gadget_is_superspeed(c->cdev->gadget)) {
9539+ ncm_ss_in_desc.bEndpointAddress =
9540+ fs_ncm_in_desc.bEndpointAddress;
9541+ ncm_ss_out_desc.bEndpointAddress =
9542+ fs_ncm_out_desc.bEndpointAddress;
9543+ ncm_ss_notify_desc.bEndpointAddress =
9544+ fs_ncm_notify_desc.bEndpointAddress;
9545+ }
9546+
9547 status = usb_assign_descriptors(f, ncm_fs_function, ncm_hs_function,
9548- NULL);
9549+ ncm_ss_function);
9550 /*
9551 * NOTE: all that is done without knowing or caring about
9552 * the network link ... which is unavailable to this code
9553@@ -1275,20 +1371,6 @@ ncm_unbind(struct usb_configuration *c, struct usb_function *f)
9554 kfree(ncm);
9555 }
9556
9557-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
9558-/**
9559- * ncm_ntb_out_size - set the max ntb out size for uplink.
9560- *
9561- */
9562-void ncm_ntb_out_size(u32 ntb_out_size)
9563-{
9564- if (ntb_out_size)
9565- ntb_parameters.dwNtbOutMaxSize = ntb_out_size;
9566- pr_info("ntb_parameters.dwNtbOutMaxSize = %d\n",
9567- ntb_parameters.dwNtbOutMaxSize);
9568-}
9569-#endif
9570-
9571 /**
9572 * ncm_bind_config - add CDC Network link to a configuration
9573 * @c: the configuration to support the network link
9574@@ -1317,11 +1399,11 @@ int ncm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN],
9575 ncm_control_intf.iInterface =
9576 ncm_string_defs[STRING_CTRL_IDX].id;
9577
9578- status = ncm_string_defs[STRING_DATA_IDX].id;
9579+ status = ncm_string_defs[NCM_STRING_DATA_IDX].id;
9580 ncm_data_nop_intf.iInterface = status;
9581 ncm_data_intf.iInterface = status;
9582
9583- ecm_desc.iMACAddress = ncm_string_defs[STRING_MAC_IDX].id;
9584+ necm_desc.iMACAddress = ncm_string_defs[STRING_MAC_IDX].id;
9585 ncm_iad_desc.iFunction = ncm_string_defs[STRING_IAD_IDX].id;
9586 }
9587
9588diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
9589index 1bf5f4a..d94a727 100644
9590--- a/drivers/usb/gadget/f_rndis.c
9591+++ b/drivers/usb/gadget/f_rndis.c
9592@@ -25,7 +25,6 @@
9593 #include "u_ether.h"
9594 #include "rndis.h"
9595
9596-
9597 /*
9598 * This function is an RNDIS Ethernet port -- a Microsoft protocol that's
9599 * been promoted instead of the standard CDC Ethernet. The published RNDIS
9600@@ -67,6 +66,20 @@
9601 * - MS-Windows drivers sometimes emit undocumented requests.
9602 */
9603
9604+static unsigned int rndis_dl_max_pkt_per_xfer = 3;
9605+module_param(rndis_dl_max_pkt_per_xfer, uint, S_IRUGO | S_IWUSR);
9606+MODULE_PARM_DESC(rndis_dl_max_pkt_per_xfer,
9607+ "Maximum packets per transfer for DL aggregation");
9608+
9609+static unsigned int rndis_ul_max_pkt_per_xfer = 3;
9610+module_param(rndis_ul_max_pkt_per_xfer, uint, S_IRUGO | S_IWUSR);
9611+MODULE_PARM_DESC(rndis_ul_max_pkt_per_xfer,
9612+ "Maximum packets per transfer for UL aggregation");
9613+
9614+static unsigned int rx_trigger_enabled;
9615+module_param(rx_trigger_enabled, uint, S_IRUGO | S_IWUSR);
9616+MODULE_PARM_DESC(rx_trigger_enabled, "rx trigger_enable");
9617+
9618 struct f_rndis {
9619 struct gether port;
9620 u8 ctrl_id, data_id;
9621@@ -80,6 +93,28 @@ struct f_rndis {
9622 atomic_t notify_count;
9623 };
9624
9625+static struct f_rndis *__rndis;
9626+
9627+int
9628+rndis_rx_trigger(void)
9629+{
9630+ struct f_rndis *rndis = __rndis;
9631+
9632+ if (!rx_trigger_enabled || !rndis) {
9633+ pr_err("can't set rx trigger\n");
9634+ return -EINVAL;
9635+ }
9636+
9637+ if (rndis->port.rx_triggered)
9638+ return 0;
9639+
9640+
9641+ rndis->port.rx_triggered = true;
9642+ gether_up(&rndis->port);
9643+
9644+ return 0;
9645+}
9646+
9647 static inline struct f_rndis *func_to_rndis(struct usb_function *f)
9648 {
9649 return container_of(f, struct f_rndis, port.func);
9650@@ -364,27 +399,42 @@ static struct usb_gadget_strings *rndis_strings[] = {
9651 NULL,
9652 };
9653
9654-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
9655-#define DMA_ALIGN_ROOM 4
9656-#endif
9657-
9658 /*-------------------------------------------------------------------------*/
9659
9660 static struct sk_buff *rndis_add_header(struct gether *port,
9661 struct sk_buff *skb)
9662 {
9663 struct sk_buff *skb2;
9664-
9665- skb2 = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type)
9666-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
9667- + DMA_ALIGN_ROOM
9668-#endif
9669- );
9670- if (skb2)
9671- rndis_add_hdr(skb2);
9672-
9673- dev_kfree_skb_any(skb);
9674- return skb2;
9675+ struct rndis_packet_msg_type *header = NULL;
9676+ struct f_rndis *rndis = func_to_rndis(&port->func);
9677+ struct usb_composite_dev *cdev = port->func.config->cdev;
9678+
9679+ if (rndis->port.multi_pkt_xfer || cdev->gadget->sg_supported) {
9680+ if (port->header) {
9681+ header = port->header;
9682+ header->MessageType = cpu_to_le32(RNDIS_MSG_PACKET);
9683+ header->MessageLength = cpu_to_le32(skb->len +
9684+ sizeof(*header));
9685+ header->DataOffset = cpu_to_le32(36);
9686+ header->DataLength = cpu_to_le32(skb->len);
9687+ pr_debug("MessageLength:%d DataLength:%d\n",
9688+ header->MessageLength,
9689+ header->DataLength);
9690+ return skb;
9691+ } else {
9692+ dev_kfree_skb_any(skb);
9693+ pr_err("RNDIS header is NULL.\n");
9694+ return NULL;
9695+ }
9696+ } else {
9697+ skb2 = skb_realloc_headroom(skb,
9698+ sizeof(struct rndis_packet_msg_type));
9699+ if (skb2)
9700+ rndis_add_hdr(skb2);
9701+
9702+ dev_kfree_skb_any(skb);
9703+ return skb2;
9704+ }
9705 }
9706
9707 static void rndis_response_available(void *_rndis)
9708@@ -398,6 +448,8 @@ static void rndis_response_available(void *_rndis)
9709 if (atomic_inc_return(&rndis->notify_count) != 1)
9710 return;
9711
9712+ if (!rndis->notify->driver_data)
9713+ return;
9714 /* Send RNDIS RESPONSE_AVAILABLE notification; a
9715 * USB_CDC_NOTIFY_RESPONSE_AVAILABLE "should" work too
9716 *
9717@@ -416,16 +468,13 @@ static void rndis_response_available(void *_rndis)
9718 static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
9719 {
9720 struct f_rndis *rndis = req->context;
9721- struct usb_composite_dev *cdev = NULL;
9722+ struct usb_composite_dev *cdev;
9723 int status = req->status;
9724
9725- /* In usb plug in/out and tetherring on/off
9726- * regression tests, port.func.config */
9727- /* may be NULL pointer.*/
9728- if (rndis->port.func.config != NULL)
9729- cdev = rndis->port.func.config->cdev;
9730+ if (!rndis->port.func.config || !rndis->port.func.config->cdev)
9731+ return;
9732 else
9733- printk(KERN_ERR "rndis gadget driver is removed.\n");
9734+ cdev = rndis->port.func.config->cdev;
9735
9736 /* after TX:
9737 * - USB_CDC_GET_ENCAPSULATED_RESPONSE (ep0/control)
9738@@ -438,8 +487,7 @@ static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
9739 atomic_set(&rndis->notify_count, 0);
9740 break;
9741 default:
9742- if (cdev != NULL)
9743- DBG(cdev, "RNDIS %s response error %d, %d/%d\n",
9744+ DBG(cdev, "RNDIS %s response error %d, %d/%d\n",
9745 ep->name, status,
9746 req->actual, req->length);
9747 /* FALLTHROUGH */
9748@@ -455,32 +503,63 @@ static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
9749 status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
9750 if (status) {
9751 atomic_dec(&rndis->notify_count);
9752- if (cdev != NULL)
9753- DBG(cdev, "notify/1 --> %d\n", status);
9754+ DBG(cdev, "notify/1 --> %d\n", status);
9755 }
9756 break;
9757 }
9758 }
9759
9760+#define MAX_PKTS_PER_XFER 10
9761 static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)
9762 {
9763 struct f_rndis *rndis = req->context;
9764- struct usb_composite_dev *cdev = NULL;
9765+ struct usb_composite_dev *cdev;
9766 int status;
9767+ rndis_init_msg_type *buf;
9768
9769- /* In usb plug in/out regression tests, port.func.config */
9770- /* may be NULL pointer.*/
9771- if (rndis->port.func.config != NULL)
9772- cdev = rndis->port.func.config->cdev;
9773+ if (!rndis->port.func.config || !rndis->port.func.config->cdev)
9774+ return;
9775 else
9776- printk(KERN_ERR "rndis gadget driver is removed.\n");
9777+ cdev = rndis->port.func.config->cdev;
9778
9779 /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
9780 // spin_lock(&dev->lock);
9781 status = rndis_msg_parser(rndis->config, (u8 *) req->buf);
9782- if ((status < 0) && (cdev != NULL))
9783- ERROR(cdev, "RNDIS command error %d, %d/%d\n",
9784+ if (status < 0)
9785+ pr_err("RNDIS command error %d, %d/%d\n",
9786 status, req->actual, req->length);
9787+
9788+ buf = (rndis_init_msg_type *)req->buf;
9789+
9790+ if (buf->MessageType == RNDIS_MSG_INIT) {
9791+ if (cdev->gadget->sg_supported) {
9792+ rndis->port.dl_max_xfer_size = buf->MaxTransferSize;
9793+ gether_update_dl_max_xfer_size(&rndis->port,
9794+ rndis->port.dl_max_xfer_size);
9795+
9796+ /* if SG is enabled multiple packets can be put
9797+ * together too quickly. However, module param
9798+ * is not honored.
9799+ */
9800+ rndis->port.dl_max_pkts_per_xfer = 5;
9801+
9802+ gether_update_dl_max_pkts_per_xfer(&rndis->port,
9803+ rndis->port.dl_max_pkts_per_xfer);
9804+
9805+ return;
9806+ }
9807+
9808+ if (buf->MaxTransferSize > 2048)
9809+ rndis->port.multi_pkt_xfer = 1;
9810+ else
9811+ rndis->port.multi_pkt_xfer = 0;
9812+ DBG(cdev, "%s: MaxTransferSize: %d : Multi_pkt_txr: %s\n",
9813+ __func__, buf->MaxTransferSize,
9814+ rndis->port.multi_pkt_xfer ? "enabled" :
9815+ "disabled");
9816+ if (rndis_dl_max_pkt_per_xfer <= 1)
9817+ rndis->port.multi_pkt_xfer = 0;
9818+ }
9819 // spin_unlock(&dev->lock);
9820 }
9821
9822@@ -582,6 +661,8 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
9823 } else if (intf == rndis->data_id) {
9824 struct net_device *net;
9825
9826+ rndis->port.rx_triggered = false;
9827+
9828 if (rndis->port.in_ep->driver_data) {
9829 DBG(cdev, "reset rndis\n");
9830 gether_disconnect(&rndis->port);
9831@@ -616,7 +697,8 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
9832 */
9833 rndis->port.cdc_filter = 0;
9834
9835- DBG(cdev, "RNDIS RX/TX early activation ... \n");
9836+ DBG(cdev, "RNDIS RX/TX early activation ...\n");
9837+ gether_enable_sg(&rndis->port, true);
9838 net = gether_connect(&rndis->port);
9839 if (IS_ERR(net))
9840 return PTR_ERR(net);
9841@@ -774,6 +856,7 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
9842
9843 rndis_set_param_medium(rndis->config, RNDIS_MEDIUM_802_3, 0);
9844 rndis_set_host_mac(rndis->config, rndis->ethaddr);
9845+ rndis_set_max_pkt_xfer(rndis->config, rndis_ul_max_pkt_per_xfer);
9846
9847 if (rndis->manufacturer && rndis->vendorID &&
9848 rndis_set_param_vendor(rndis->config, rndis->vendorID,
9849@@ -827,6 +910,7 @@ rndis_unbind(struct usb_configuration *c, struct usb_function *f)
9850 usb_ep_free_request(rndis->notify, rndis->notify_req);
9851
9852 kfree(rndis);
9853+ __rndis = NULL;
9854 }
9855
9856 /* Some controllers can't support RNDIS ... */
9857@@ -867,6 +951,8 @@ rndis_bind_config_vendor(struct usb_configuration *c, u8 ethaddr[ETH_ALEN],
9858 if (!rndis)
9859 goto fail;
9860
9861+ __rndis = rndis;
9862+
9863 memcpy(rndis->ethaddr, ethaddr, ETH_ALEN);
9864 rndis->vendorID = vendorID;
9865 rndis->manufacturer = manufacturer;
9866@@ -879,6 +965,9 @@ rndis_bind_config_vendor(struct usb_configuration *c, u8 ethaddr[ETH_ALEN],
9867 rndis->port.header_len = sizeof(struct rndis_packet_msg_type);
9868 rndis->port.wrap = rndis_add_header;
9869 rndis->port.unwrap = rndis_rm_hdr;
9870+ rndis->port.ul_max_pkts_per_xfer = rndis_ul_max_pkt_per_xfer;
9871+ rndis->port.dl_max_pkts_per_xfer = rndis_dl_max_pkt_per_xfer;
9872+ rndis->port.rx_trigger_enabled = rx_trigger_enabled;
9873
9874 rndis->port.func.name = "rndis";
9875 rndis->port.func.strings = rndis_strings;
9876diff --git a/drivers/usb/gadget/f_serial.c b/drivers/usb/gadget/f_serial.c
9877index 981113c..7190194 100644
9878--- a/drivers/usb/gadget/f_serial.c
9879+++ b/drivers/usb/gadget/f_serial.c
9880@@ -4,6 +4,7 @@
9881 * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
9882 * Copyright (C) 2008 by David Brownell
9883 * Copyright (C) 2008 by Nokia Corporation
9884+ * Copyright (c) 2014, The Linux Foundation. All rights reserved.
9885 *
9886 * This software is distributed under the terms of the GNU General
9887 * Public License ("GPL") as published by the Free Software Foundation,
9888@@ -14,6 +15,13 @@
9889 #include <linux/kernel.h>
9890 #include <linux/module.h>
9891 #include <linux/device.h>
9892+#include <linux/miscdevice.h>
9893+#include <linux/uaccess.h>
9894+#include <linux/fs.h>
9895+#include <linux/usb/composite.h>
9896+#include <linux/tty.h>
9897+
9898+#include "usb_gadget_xport.h"
9899
9900 #include "u_serial.h"
9901 #include "gadget_chips.h"
9902@@ -28,17 +36,109 @@
9903 * if you can arrange appropriate host side drivers.
9904 */
9905
9906+#define GSERIAL_IOCTL_MAGIC 'G'
9907+#define GSERIAL_SET_XPORT_TYPE _IOW(GSERIAL_IOCTL_MAGIC, 0, u32)
9908+#define GSERIAL_SMD_WRITE _IOW(GSERIAL_IOCTL_MAGIC, 1, \
9909+ struct ioctl_smd_write_arg_type)
9910+
9911+#define GSERIAL_SET_XPORT_TYPE_TTY 0
9912+#define GSERIAL_SET_XPORT_TYPE_SMD 1
9913+
9914+#define GSERIAL_BUF_LEN 256
9915+#define GSERIAL_NO_PORTS 3
9916+
9917+struct ioctl_smd_write_arg_type {
9918+ char *buf;
9919+ unsigned int size;
9920+};
9921+
9922 struct f_gser {
9923 struct gserial port;
9924 u8 data_id;
9925 u8 port_num;
9926+
9927+ u8 online;
9928+ enum transport_type transport;
9929+
9930+ atomic_t ioctl_excl;
9931+ atomic_t open_excl;
9932+
9933+#ifdef CONFIG_MODEM_SUPPORT
9934+ u8 pending;
9935+ spinlock_t lock;
9936+ struct usb_ep *notify;
9937+ struct usb_request *notify_req;
9938+
9939+ struct usb_cdc_line_coding port_line_coding;
9940+
9941+ /* SetControlLineState request */
9942+ u16 port_handshake_bits;
9943+#define ACM_CTRL_RTS (1 << 1) /* unused with full duplex */
9944+#define ACM_CTRL_DTR (1 << 0) /* host is ready for data r/w */
9945+
9946+ /* SerialState notification */
9947+ u16 serial_state;
9948+#define ACM_CTRL_OVERRUN (1 << 6)
9949+#define ACM_CTRL_PARITY (1 << 5)
9950+#define ACM_CTRL_FRAMING (1 << 4)
9951+#define ACM_CTRL_RI (1 << 3)
9952+#define ACM_CTRL_BRK (1 << 2)
9953+#define ACM_CTRL_DSR (1 << 1)
9954+#define ACM_CTRL_DCD (1 << 0)
9955+#endif
9956 };
9957
9958+
9959+static unsigned int no_tty_ports;
9960+static unsigned int no_smd_ports;
9961+static unsigned int no_hsic_sports;
9962+static unsigned int no_hsuart_sports;
9963+static unsigned int nr_ports;
9964+static unsigned int gser_next_free_port;
9965+
9966+static struct port_info {
9967+ enum transport_type transport;
9968+ unsigned port_num;
9969+ unsigned char client_port_num;
9970+ struct f_gser *gser_ptr;
9971+ bool dun_w_softap_enable;
9972+} gserial_ports[GSERIAL_NO_PORTS];
9973+
9974+static int gser_open_dev(struct inode *ip, struct file *fp);
9975+static int gser_release_dev(struct inode *ip, struct file *fp);
9976+static long gser_ioctl(struct file *fp, unsigned cmd, unsigned long arg);
9977+static void gser_ioctl_set_transport(struct f_gser *gser,
9978+ unsigned int transport);
9979+
9980+
9981+static const struct file_operations gser_fops = {
9982+ .owner = THIS_MODULE,
9983+ .open = gser_open_dev,
9984+ .release = gser_release_dev,
9985+ .unlocked_ioctl = gser_ioctl,
9986+};
9987+
9988+static struct miscdevice gser_device = {
9989+ .minor = MISC_DYNAMIC_MINOR,
9990+ .name = "android_serial_device",
9991+ .fops = &gser_fops,
9992+};
9993+
9994+static int registered;
9995+
9996 static inline struct f_gser *func_to_gser(struct usb_function *f)
9997 {
9998 return container_of(f, struct f_gser, port.func);
9999 }
10000
10001+#ifdef CONFIG_MODEM_SUPPORT
10002+static inline struct f_gser *port_to_gser(struct gserial *p)
10003+{
10004+ return container_of(p, struct f_gser, port);
10005+}
10006+#define GS_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */
10007+#define GS_NOTIFY_MAXPACKET 10 /* notification + 2 bytes */
10008+#endif
10009 /*-------------------------------------------------------------------------*/
10010
10011 /* interface descriptor: */
10012@@ -47,14 +147,59 @@ static struct usb_interface_descriptor gser_interface_desc = {
10013 .bLength = USB_DT_INTERFACE_SIZE,
10014 .bDescriptorType = USB_DT_INTERFACE,
10015 /* .bInterfaceNumber = DYNAMIC */
10016+#ifdef CONFIG_MODEM_SUPPORT
10017+ .bNumEndpoints = 3,
10018+#else
10019 .bNumEndpoints = 2,
10020+#endif
10021 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
10022 .bInterfaceSubClass = 0,
10023 .bInterfaceProtocol = 0,
10024 /* .iInterface = DYNAMIC */
10025 };
10026+#ifdef CONFIG_MODEM_SUPPORT
10027+static struct usb_cdc_header_desc gser_header_desc = {
10028+ .bLength = sizeof(gser_header_desc),
10029+ .bDescriptorType = USB_DT_CS_INTERFACE,
10030+ .bDescriptorSubType = USB_CDC_HEADER_TYPE,
10031+ .bcdCDC = __constant_cpu_to_le16(0x0110),
10032+};
10033+
10034+static struct usb_cdc_call_mgmt_descriptor
10035+gser_call_mgmt_descriptor = {
10036+ .bLength = sizeof(gser_call_mgmt_descriptor),
10037+ .bDescriptorType = USB_DT_CS_INTERFACE,
10038+ .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
10039+ .bmCapabilities = 0,
10040+ /* .bDataInterface = DYNAMIC */
10041+};
10042+
10043+static struct usb_cdc_acm_descriptor gser_descriptor = {
10044+ .bLength = sizeof(gser_descriptor),
10045+ .bDescriptorType = USB_DT_CS_INTERFACE,
10046+ .bDescriptorSubType = USB_CDC_ACM_TYPE,
10047+ .bmCapabilities = USB_CDC_CAP_LINE,
10048+};
10049
10050+static struct usb_cdc_union_desc gser_union_desc = {
10051+ .bLength = sizeof(gser_union_desc),
10052+ .bDescriptorType = USB_DT_CS_INTERFACE,
10053+ .bDescriptorSubType = USB_CDC_UNION_TYPE,
10054+ /* .bMasterInterface0 = DYNAMIC */
10055+ /* .bSlaveInterface0 = DYNAMIC */
10056+};
10057+#endif
10058 /* full speed support: */
10059+#ifdef CONFIG_MODEM_SUPPORT
10060+static struct usb_endpoint_descriptor gser_fs_notify_desc = {
10061+ .bLength = USB_DT_ENDPOINT_SIZE,
10062+ .bDescriptorType = USB_DT_ENDPOINT,
10063+ .bEndpointAddress = USB_DIR_IN,
10064+ .bmAttributes = USB_ENDPOINT_XFER_INT,
10065+ .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
10066+ .bInterval = 1 << GS_LOG2_NOTIFY_INTERVAL,
10067+};
10068+#endif
10069
10070 static struct usb_endpoint_descriptor gser_fs_in_desc = {
10071 .bLength = USB_DT_ENDPOINT_SIZE,
10072@@ -72,29 +217,53 @@ static struct usb_endpoint_descriptor gser_fs_out_desc = {
10073
10074 static struct usb_descriptor_header *gser_fs_function[] = {
10075 (struct usb_descriptor_header *) &gser_interface_desc,
10076+#ifdef CONFIG_MODEM_SUPPORT
10077+ (struct usb_descriptor_header *) &gser_header_desc,
10078+ (struct usb_descriptor_header *) &gser_call_mgmt_descriptor,
10079+ (struct usb_descriptor_header *) &gser_descriptor,
10080+ (struct usb_descriptor_header *) &gser_union_desc,
10081+ (struct usb_descriptor_header *) &gser_fs_notify_desc,
10082+#endif
10083 (struct usb_descriptor_header *) &gser_fs_in_desc,
10084 (struct usb_descriptor_header *) &gser_fs_out_desc,
10085 NULL,
10086 };
10087
10088 /* high speed support: */
10089+#ifdef CONFIG_MODEM_SUPPORT
10090+static struct usb_endpoint_descriptor gser_hs_notify_desc = {
10091+ .bLength = USB_DT_ENDPOINT_SIZE,
10092+ .bDescriptorType = USB_DT_ENDPOINT,
10093+ .bEndpointAddress = USB_DIR_IN,
10094+ .bmAttributes = USB_ENDPOINT_XFER_INT,
10095+ .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
10096+ .bInterval = GS_LOG2_NOTIFY_INTERVAL+4,
10097+};
10098+#endif
10099
10100 static struct usb_endpoint_descriptor gser_hs_in_desc = {
10101 .bLength = USB_DT_ENDPOINT_SIZE,
10102 .bDescriptorType = USB_DT_ENDPOINT,
10103 .bmAttributes = USB_ENDPOINT_XFER_BULK,
10104- .wMaxPacketSize = cpu_to_le16(512),
10105+ .wMaxPacketSize = __constant_cpu_to_le16(512),
10106 };
10107
10108 static struct usb_endpoint_descriptor gser_hs_out_desc = {
10109 .bLength = USB_DT_ENDPOINT_SIZE,
10110 .bDescriptorType = USB_DT_ENDPOINT,
10111 .bmAttributes = USB_ENDPOINT_XFER_BULK,
10112- .wMaxPacketSize = cpu_to_le16(512),
10113+ .wMaxPacketSize = __constant_cpu_to_le16(512),
10114 };
10115
10116 static struct usb_descriptor_header *gser_hs_function[] = {
10117 (struct usb_descriptor_header *) &gser_interface_desc,
10118+#ifdef CONFIG_MODEM_SUPPORT
10119+ (struct usb_descriptor_header *) &gser_header_desc,
10120+ (struct usb_descriptor_header *) &gser_call_mgmt_descriptor,
10121+ (struct usb_descriptor_header *) &gser_descriptor,
10122+ (struct usb_descriptor_header *) &gser_union_desc,
10123+ (struct usb_descriptor_header *) &gser_hs_notify_desc,
10124+#endif
10125 (struct usb_descriptor_header *) &gser_hs_in_desc,
10126 (struct usb_descriptor_header *) &gser_hs_out_desc,
10127 NULL,
10128@@ -119,8 +288,37 @@ static struct usb_ss_ep_comp_descriptor gser_ss_bulk_comp_desc = {
10129 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
10130 };
10131
10132+#ifdef CONFIG_MODEM_SUPPORT
10133+static struct usb_endpoint_descriptor gser_ss_notify_desc = {
10134+ .bLength = USB_DT_ENDPOINT_SIZE,
10135+ .bDescriptorType = USB_DT_ENDPOINT,
10136+ .bEndpointAddress = USB_DIR_IN,
10137+ .bmAttributes = USB_ENDPOINT_XFER_INT,
10138+ .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
10139+ .bInterval = GS_LOG2_NOTIFY_INTERVAL+4,
10140+};
10141+
10142+static struct usb_ss_ep_comp_descriptor gser_ss_notify_comp_desc = {
10143+ .bLength = sizeof gser_ss_notify_comp_desc,
10144+ .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
10145+
10146+ /* the following 2 values can be tweaked if necessary */
10147+ /* .bMaxBurst = 0, */
10148+ /* .bmAttributes = 0, */
10149+ .wBytesPerInterval = cpu_to_le16(GS_NOTIFY_MAXPACKET),
10150+};
10151+#endif
10152+
10153 static struct usb_descriptor_header *gser_ss_function[] = {
10154 (struct usb_descriptor_header *) &gser_interface_desc,
10155+#ifdef CONFIG_MODEM_SUPPORT
10156+ (struct usb_descriptor_header *) &gser_header_desc,
10157+ (struct usb_descriptor_header *) &gser_call_mgmt_descriptor,
10158+ (struct usb_descriptor_header *) &gser_descriptor,
10159+ (struct usb_descriptor_header *) &gser_union_desc,
10160+ (struct usb_descriptor_header *) &gser_ss_notify_desc,
10161+ (struct usb_descriptor_header *) &gser_ss_notify_comp_desc,
10162+#endif
10163 (struct usb_descriptor_header *) &gser_ss_in_desc,
10164 (struct usb_descriptor_header *) &gser_ss_bulk_comp_desc,
10165 (struct usb_descriptor_header *) &gser_ss_out_desc,
10166@@ -145,18 +343,283 @@ static struct usb_gadget_strings *gser_strings[] = {
10167 NULL,
10168 };
10169
10170+int gport_setup(struct usb_configuration *c)
10171+{
10172+ int ret = 0;
10173+ int port_idx;
10174+ int i;
10175+
10176+ pr_debug("%s: no_tty_ports: %u "
10177+ " no_smd_ports: %u no_hsic_sports: %u no_hsuart_ports: %u nr_ports: %u\n",
10178+ __func__, no_tty_ports, no_smd_ports,
10179+ no_hsic_sports, no_hsuart_sports, nr_ports);
10180+
10181+ if (no_tty_ports) {
10182+ for (i = 0; i < no_tty_ports; i++) {
10183+ ret = gserial_alloc_line(
10184+ &gserial_ports[i].client_port_num);
10185+ if (ret)
10186+ return ret;
10187+ }
10188+ }
10189+
10190+ if (no_smd_ports)
10191+ ret = gsmd_setup(c->cdev->gadget, no_smd_ports);
10192+ if (no_hsic_sports) {
10193+ port_idx = ghsic_data_setup(no_hsic_sports, USB_GADGET_SERIAL);
10194+ if (port_idx < 0)
10195+ return port_idx;
10196+
10197+ for (i = 0; i < nr_ports; i++) {
10198+ if (gserial_ports[i].transport ==
10199+ USB_GADGET_XPORT_HSIC) {
10200+ gserial_ports[i].client_port_num = port_idx;
10201+ port_idx++;
10202+ }
10203+ }
10204+
10205+ /*clinet port num is same for data setup and ctrl setup*/
10206+ ret = ghsic_ctrl_setup(no_hsic_sports, USB_GADGET_SERIAL);
10207+ if (ret < 0)
10208+ return ret;
10209+ }
10210+ if (no_hsuart_sports) {
10211+ port_idx = ghsuart_data_setup(no_hsuart_sports,
10212+ USB_GADGET_SERIAL);
10213+ if (port_idx < 0)
10214+ return port_idx;
10215+
10216+ for (i = 0; i < nr_ports; i++) {
10217+ if (gserial_ports[i].transport ==
10218+ USB_GADGET_XPORT_HSUART) {
10219+ gserial_ports[i].client_port_num = port_idx;
10220+ port_idx++;
10221+ }
10222+ }
10223+ }
10224+ return ret;
10225+}
10226+
10227+void gport_cleanup(void)
10228+{
10229+ int i;
10230+
10231+ for (i = 0; i < no_tty_ports; i++)
10232+ gserial_free_line(gserial_ports[i].client_port_num);
10233+}
10234+
10235+static int gport_connect(struct f_gser *gser)
10236+{
10237+ unsigned port_num;
10238+ int ret;
10239+
10240+ pr_debug("%s: transport: %s f_gser: %p gserial: %p port_num: %d\n",
10241+ __func__, xport_to_str(gser->transport),
10242+ gser, &gser->port, gser->port_num);
10243+
10244+ port_num = gserial_ports[gser->port_num].client_port_num;
10245+
10246+ switch (gser->transport) {
10247+ case USB_GADGET_XPORT_TTY:
10248+ gserial_connect(&gser->port, port_num);
10249+ break;
10250+ case USB_GADGET_XPORT_SMD:
10251+ gsmd_connect(&gser->port, port_num);
10252+ break;
10253+ case USB_GADGET_XPORT_HSIC:
10254+ ret = ghsic_ctrl_connect(&gser->port, port_num);
10255+ if (ret) {
10256+ pr_err("%s: ghsic_ctrl_connect failed: err:%d\n",
10257+ __func__, ret);
10258+ return ret;
10259+ }
10260+ ret = ghsic_data_connect(&gser->port, port_num);
10261+ if (ret) {
10262+ pr_err("%s: ghsic_data_connect failed: err:%d\n",
10263+ __func__, ret);
10264+ ghsic_ctrl_disconnect(&gser->port, port_num);
10265+ return ret;
10266+ }
10267+ break;
10268+ case USB_GADGET_XPORT_HSUART:
10269+ ret = ghsuart_data_connect(&gser->port, port_num);
10270+ if (ret) {
10271+ pr_err("%s: ghsuart_data_connect failed: err:%d\n",
10272+ __func__, ret);
10273+ return ret;
10274+ }
10275+ break;
10276+ default:
10277+ pr_err("%s: Un-supported transport: %s\n", __func__,
10278+ xport_to_str(gser->transport));
10279+ return -ENODEV;
10280+ }
10281+
10282+ return 0;
10283+}
10284+
10285+static int gport_disconnect(struct f_gser *gser)
10286+{
10287+ unsigned port_num;
10288+
10289+ port_num = gserial_ports[gser->port_num].client_port_num;
10290+
10291+ pr_debug("%s: transport: %s f_gser: %p gserial: %p port_num: %d\n",
10292+ __func__, xport_to_str(gser->transport),
10293+ gser, &gser->port, gser->port_num);
10294+
10295+ switch (gser->transport) {
10296+ case USB_GADGET_XPORT_TTY:
10297+ gserial_disconnect(&gser->port);
10298+ break;
10299+ case USB_GADGET_XPORT_SMD:
10300+ gsmd_disconnect(&gser->port, port_num);
10301+ break;
10302+ case USB_GADGET_XPORT_HSIC:
10303+ ghsic_ctrl_disconnect(&gser->port, port_num);
10304+ ghsic_data_disconnect(&gser->port, port_num);
10305+ break;
10306+ case USB_GADGET_XPORT_HSUART:
10307+ ghsuart_data_disconnect(&gser->port, port_num);
10308+ break;
10309+ default:
10310+ pr_err("%s: Un-supported transport:%s\n", __func__,
10311+ xport_to_str(gser->transport));
10312+ return -ENODEV;
10313+ }
10314+
10315+ return 0;
10316+}
10317+
10318+#ifdef CONFIG_MODEM_SUPPORT
10319+static void gser_complete_set_line_coding(struct usb_ep *ep,
10320+ struct usb_request *req)
10321+{
10322+ struct f_gser *gser = ep->driver_data;
10323+ struct usb_composite_dev *cdev = gser->port.func.config->cdev;
10324+
10325+ if (req->status != 0) {
10326+ DBG(cdev, "gser ttyGS%d completion, err %d\n",
10327+ gser->port_num, req->status);
10328+ return;
10329+ }
10330+
10331+ /* normal completion */
10332+ if (req->actual != sizeof(gser->port_line_coding)) {
10333+ DBG(cdev, "gser ttyGS%d short resp, len %d\n",
10334+ gser->port_num, req->actual);
10335+ usb_ep_set_halt(ep);
10336+ } else {
10337+ struct usb_cdc_line_coding *value = req->buf;
10338+ gser->port_line_coding = *value;
10339+ }
10340+}
10341 /*-------------------------------------------------------------------------*/
10342
10343+static int
10344+gser_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
10345+{
10346+ struct f_gser *gser = func_to_gser(f);
10347+ struct usb_composite_dev *cdev = f->config->cdev;
10348+ struct usb_request *req = cdev->req;
10349+ int value = -EOPNOTSUPP;
10350+ u16 w_index = le16_to_cpu(ctrl->wIndex);
10351+ u16 w_value = le16_to_cpu(ctrl->wValue);
10352+ u16 w_length = le16_to_cpu(ctrl->wLength);
10353+
10354+ switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
10355+
10356+ /* SET_LINE_CODING ... just read and save what the host sends */
10357+ case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
10358+ | USB_CDC_REQ_SET_LINE_CODING:
10359+ if (w_length != sizeof(struct usb_cdc_line_coding))
10360+ goto invalid;
10361+
10362+ value = w_length;
10363+ cdev->gadget->ep0->driver_data = gser;
10364+ req->complete = gser_complete_set_line_coding;
10365+ break;
10366+
10367+ /* GET_LINE_CODING ... return what host sent, or initial value */
10368+ case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
10369+ | USB_CDC_REQ_GET_LINE_CODING:
10370+ value = min_t(unsigned, w_length,
10371+ sizeof(struct usb_cdc_line_coding));
10372+ memcpy(req->buf, &gser->port_line_coding, value);
10373+ break;
10374+
10375+ /* SET_CONTROL_LINE_STATE ... save what the host sent */
10376+ case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
10377+ | USB_CDC_REQ_SET_CONTROL_LINE_STATE:
10378+
10379+ value = 0;
10380+ gser->port_handshake_bits = w_value;
10381+ if (gser->port.notify_modem) {
10382+ unsigned port_num =
10383+ gserial_ports[gser->port_num].client_port_num;
10384+
10385+ gser->port.notify_modem(&gser->port,
10386+ port_num, w_value);
10387+ }
10388+ break;
10389+
10390+ default:
10391+invalid:
10392+ DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
10393+ ctrl->bRequestType, ctrl->bRequest,
10394+ w_value, w_index, w_length);
10395+ }
10396+
10397+ /* respond with data transfer or status phase? */
10398+ if (value >= 0) {
10399+ DBG(cdev, "gser ttyGS%d req%02x.%02x v%04x i%04x l%d\n",
10400+ gser->port_num, ctrl->bRequestType, ctrl->bRequest,
10401+ w_value, w_index, w_length);
10402+ req->zero = 0;
10403+ req->length = value;
10404+ value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
10405+ if (value < 0)
10406+ ERROR(cdev, "gser response on ttyGS%d, err %d\n",
10407+ gser->port_num, value);
10408+ }
10409+
10410+ /* device either stalls (value < 0) or reports success */
10411+ return value;
10412+}
10413+#endif
10414 static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
10415 {
10416 struct f_gser *gser = func_to_gser(f);
10417 struct usb_composite_dev *cdev = f->config->cdev;
10418+ int rc = 0;
10419
10420 /* we know alt == 0, so this is an activation or a reset */
10421
10422+#ifdef CONFIG_MODEM_SUPPORT
10423+ if (gser->notify->driver_data) {
10424+ DBG(cdev, "reset generic ctl ttyGS%d\n", gser->port_num);
10425+ usb_ep_disable(gser->notify);
10426+ }
10427+
10428+ if (!gser->notify->desc) {
10429+ if (config_ep_by_speed(cdev->gadget, f, gser->notify)) {
10430+ gser->notify->desc = NULL;
10431+ return -EINVAL;
10432+ }
10433+ }
10434+ rc = usb_ep_enable(gser->notify);
10435+
10436+ if (rc) {
10437+ ERROR(cdev, "can't enable %s, result %d\n",
10438+ gser->notify->name, rc);
10439+ return rc;
10440+ }
10441+ gser->notify->driver_data = gser;
10442+#endif
10443+
10444 if (gser->port.in->driver_data) {
10445- DBG(cdev, "reset generic ttyGS%d\n", gser->port_num);
10446- gserial_disconnect(&gser->port);
10447+ DBG(cdev, "reset generic data ttyGS%d\n", gser->port_num);
10448+ gport_disconnect(gser);
10449 }
10450 if (!gser->port.in->desc || !gser->port.out->desc) {
10451 DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
10452@@ -167,8 +630,11 @@ static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
10453 return -EINVAL;
10454 }
10455 }
10456- gserial_connect(&gser->port, gser->port_num);
10457- return 0;
10458+
10459+ gport_connect(gser);
10460+
10461+ gser->online = 1;
10462+ return rc;
10463 }
10464
10465 static void gser_disable(struct usb_function *f)
10466@@ -177,9 +643,181 @@ static void gser_disable(struct usb_function *f)
10467 struct usb_composite_dev *cdev = f->config->cdev;
10468
10469 DBG(cdev, "generic ttyGS%d deactivated\n", gser->port_num);
10470- gserial_disconnect(&gser->port);
10471+
10472+ gport_disconnect(gser);
10473+
10474+#ifdef CONFIG_MODEM_SUPPORT
10475+ usb_ep_fifo_flush(gser->notify);
10476+ usb_ep_disable(gser->notify);
10477+ gser->notify->driver_data = NULL;
10478+#endif
10479+ gser->online = 0;
10480+}
10481+#ifdef CONFIG_MODEM_SUPPORT
10482+static int gser_notify(struct f_gser *gser, u8 type, u16 value,
10483+ void *data, unsigned length)
10484+{
10485+ struct usb_ep *ep = gser->notify;
10486+ struct usb_request *req;
10487+ struct usb_cdc_notification *notify;
10488+ const unsigned len = sizeof(*notify) + length;
10489+ void *buf;
10490+ int status;
10491+ struct usb_composite_dev *cdev = gser->port.func.config->cdev;
10492+
10493+ req = gser->notify_req;
10494+ gser->notify_req = NULL;
10495+ gser->pending = false;
10496+
10497+ req->length = len;
10498+ notify = req->buf;
10499+ buf = notify + 1;
10500+
10501+ notify->bmRequestType = USB_DIR_IN | USB_TYPE_CLASS
10502+ | USB_RECIP_INTERFACE;
10503+ notify->bNotificationType = type;
10504+ notify->wValue = cpu_to_le16(value);
10505+ notify->wIndex = cpu_to_le16(gser->data_id);
10506+ notify->wLength = cpu_to_le16(length);
10507+ memcpy(buf, data, length);
10508+
10509+ status = usb_ep_queue(ep, req, GFP_ATOMIC);
10510+ if (status < 0) {
10511+ ERROR(cdev, "gser ttyGS%d can't notify serial state, %d\n",
10512+ gser->port_num, status);
10513+ gser->notify_req = req;
10514+ }
10515+
10516+ return status;
10517+}
10518+
10519+static int gser_notify_serial_state(struct f_gser *gser)
10520+{
10521+ int status;
10522+ unsigned long flags;
10523+ struct usb_composite_dev *cdev = gser->port.func.config->cdev;
10524+
10525+ spin_lock_irqsave(&gser->lock, flags);
10526+ if (gser->notify_req) {
10527+ DBG(cdev, "gser ttyGS%d serial state %04x\n",
10528+ gser->port_num, gser->serial_state);
10529+ status = gser_notify(gser, USB_CDC_NOTIFY_SERIAL_STATE,
10530+ 0, &gser->serial_state,
10531+ sizeof(gser->serial_state));
10532+ } else {
10533+ gser->pending = true;
10534+ status = 0;
10535+ }
10536+ spin_unlock_irqrestore(&gser->lock, flags);
10537+ return status;
10538+}
10539+
10540+static void gser_notify_complete(struct usb_ep *ep, struct usb_request *req)
10541+{
10542+ struct f_gser *gser = req->context;
10543+ u8 doit = false;
10544+ unsigned long flags;
10545+
10546+ /* on this call path we do NOT hold the port spinlock,
10547+ * which is why ACM needs its own spinlock
10548+ */
10549+ spin_lock_irqsave(&gser->lock, flags);
10550+ if (req->status != -ESHUTDOWN)
10551+ doit = gser->pending;
10552+ gser->notify_req = req;
10553+ spin_unlock_irqrestore(&gser->lock, flags);
10554+
10555+ if (doit && gser->online)
10556+ gser_notify_serial_state(gser);
10557+}
10558+static void gser_connect(struct gserial *port)
10559+{
10560+ struct f_gser *gser = port_to_gser(port);
10561+
10562+ gser->serial_state |= ACM_CTRL_DSR | ACM_CTRL_DCD;
10563+ gser_notify_serial_state(gser);
10564+}
10565+
10566+unsigned int gser_get_dtr(struct gserial *port)
10567+{
10568+ struct f_gser *gser = port_to_gser(port);
10569+
10570+ if (gser->port_handshake_bits & ACM_CTRL_DTR)
10571+ return 1;
10572+ else
10573+ return 0;
10574+}
10575+
10576+unsigned int gser_get_rts(struct gserial *port)
10577+{
10578+ struct f_gser *gser = port_to_gser(port);
10579+
10580+ if (gser->port_handshake_bits & ACM_CTRL_RTS)
10581+ return 1;
10582+ else
10583+ return 0;
10584+}
10585+
10586+unsigned int gser_send_carrier_detect(struct gserial *port, unsigned int yes)
10587+{
10588+ struct f_gser *gser = port_to_gser(port);
10589+ u16 state;
10590+
10591+ state = gser->serial_state;
10592+ state &= ~ACM_CTRL_DCD;
10593+ if (yes)
10594+ state |= ACM_CTRL_DCD;
10595+
10596+ gser->serial_state = state;
10597+ return gser_notify_serial_state(gser);
10598+
10599+}
10600+
10601+unsigned int gser_send_ring_indicator(struct gserial *port, unsigned int yes)
10602+{
10603+ struct f_gser *gser = port_to_gser(port);
10604+ u16 state;
10605+
10606+ state = gser->serial_state;
10607+ state &= ~ACM_CTRL_RI;
10608+ if (yes)
10609+ state |= ACM_CTRL_RI;
10610+
10611+ gser->serial_state = state;
10612+ return gser_notify_serial_state(gser);
10613+
10614 }
10615+static void gser_disconnect(struct gserial *port)
10616+{
10617+ struct f_gser *gser = port_to_gser(port);
10618+
10619+ gser->serial_state &= ~(ACM_CTRL_DSR | ACM_CTRL_DCD);
10620+ gser_notify_serial_state(gser);
10621+}
10622+
10623+static int gser_send_break(struct gserial *port, int duration)
10624+{
10625+ struct f_gser *gser = port_to_gser(port);
10626+ u16 state;
10627+
10628+ state = gser->serial_state;
10629+ state &= ~ACM_CTRL_BRK;
10630+ if (duration)
10631+ state |= ACM_CTRL_BRK;
10632
10633+ gser->serial_state = state;
10634+ return gser_notify_serial_state(gser);
10635+}
10636+
10637+static int gser_send_modem_ctrl_bits(struct gserial *port, int ctrl_bits)
10638+{
10639+ struct f_gser *gser = port_to_gser(port);
10640+
10641+ gser->serial_state = ctrl_bits;
10642+
10643+ return gser_notify_serial_state(gser);
10644+}
10645+#endif
10646 /*-------------------------------------------------------------------------*/
10647
10648 /* serial function driver setup/binding */
10649@@ -225,6 +863,23 @@ static int gser_bind(struct usb_configuration *c, struct usb_function *f)
10650 gser->port.out = ep;
10651 ep->driver_data = cdev; /* claim */
10652
10653+#ifdef CONFIG_MODEM_SUPPORT
10654+ ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_notify_desc);
10655+ if (!ep)
10656+ goto fail;
10657+ gser->notify = ep;
10658+ ep->driver_data = cdev; /* claim */
10659+ /* allocate notification */
10660+ gser->notify_req = gs_alloc_req(ep,
10661+ sizeof(struct usb_cdc_notification) + 2,
10662+ GFP_KERNEL);
10663+ if (!gser->notify_req)
10664+ goto fail;
10665+
10666+ gser->notify_req->complete = gser_notify_complete;
10667+ gser->notify_req->context = gser;
10668+#endif
10669+
10670 /* support all relevant hardware speeds... we expect that when
10671 * hardware is dual speed, all bulk-capable endpoints work at
10672 * both speeds
10673@@ -235,10 +890,26 @@ static int gser_bind(struct usb_configuration *c, struct usb_function *f)
10674 gser_ss_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress;
10675 gser_ss_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;
10676
10677+ if (gadget_is_dualspeed(c->cdev->gadget)) {
10678+#ifdef CONFIG_MODEM_SUPPORT
10679+ gser_hs_notify_desc.bEndpointAddress =
10680+ gser_fs_notify_desc.bEndpointAddress;
10681+#endif
10682+ }
10683+ if (gadget_is_superspeed(c->cdev->gadget)) {
10684+#ifdef CONFIG_MODEM_SUPPORT
10685+ gser_ss_notify_desc.bEndpointAddress =
10686+ gser_fs_notify_desc.bEndpointAddress;
10687+#endif
10688+ }
10689+
10690 status = usb_assign_descriptors(f, gser_fs_function, gser_hs_function,
10691 gser_ss_function);
10692 if (status)
10693 goto fail;
10694+
10695+ gserial_ports[gser->port_num].gser_ptr = gser;
10696+
10697 DBG(cdev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
10698 gser->port_num,
10699 gadget_is_superspeed(c->cdev->gadget) ? "super" :
10700@@ -247,6 +918,14 @@ static int gser_bind(struct usb_configuration *c, struct usb_function *f)
10701 return 0;
10702
10703 fail:
10704+#ifdef CONFIG_MODEM_SUPPORT
10705+ if (gser->notify_req)
10706+ gs_free_req(gser->notify, gser->notify_req);
10707+
10708+ /* we might as well release our claims on endpoints */
10709+ if (gser->notify)
10710+ gser->notify->driver_data = NULL;
10711+#endif
10712 /* we might as well release our claims on endpoints */
10713 if (gser->port.out)
10714 gser->port.out->driver_data = NULL;
10715@@ -316,7 +995,9 @@ static void gser_free_inst(struct usb_function_instance *f)
10716 struct f_serial_opts *opts;
10717
10718 opts = container_of(f, struct f_serial_opts, func_inst);
10719- gserial_free_line(opts->port_num);
10720+ if (!nr_ports)
10721+ gserial_free_line(opts->port_num);
10722+
10723 kfree(opts);
10724 }
10725
10726@@ -330,10 +1011,14 @@ static struct usb_function_instance *gser_alloc_inst(void)
10727 return ERR_PTR(-ENOMEM);
10728
10729 opts->func_inst.free_func_inst = gser_free_inst;
10730- ret = gserial_alloc_line(&opts->port_num);
10731- if (ret) {
10732- kfree(opts);
10733- return ERR_PTR(ret);
10734+
10735+ /* Check if tty registration is handled here or not */
10736+ if (!nr_ports) {
10737+ ret = gserial_alloc_line(&opts->port_num);
10738+ if (ret) {
10739+ kfree(opts);
10740+ return ERR_PTR(ret);
10741+ }
10742 }
10743 config_group_init_type_name(&opts->func_inst.group, "",
10744 &serial_func_type);
10745@@ -346,12 +1031,41 @@ static void gser_free(struct usb_function *f)
10746 struct f_gser *serial;
10747
10748 serial = func_to_gser(f);
10749+ pr_debug("%s: port %d", __func__, serial->port_num);
10750+
10751+ gserial_ports[serial->port_num].gser_ptr = NULL;
10752 kfree(serial);
10753+ gser_next_free_port--;
10754 }
10755
10756 static void gser_unbind(struct usb_configuration *c, struct usb_function *f)
10757 {
10758+ struct f_gser *gser = func_to_gser(f);
10759+
10760 usb_free_all_descriptors(f);
10761+#ifdef CONFIG_MODEM_SUPPORT
10762+ gs_free_req(gser->notify, gser->notify_req);
10763+#endif
10764+
10765+ gserial_ports[gser->port_num].gser_ptr = NULL;
10766+}
10767+
10768+static int gser_init(void)
10769+{
10770+ int ret;
10771+
10772+ pr_debug("%s: initialize serial function instance", __func__);
10773+
10774+ if (registered)
10775+ return 0;
10776+
10777+ ret = misc_register(&gser_device);
10778+ if (ret)
10779+ pr_err("Serial driver failed to register");
10780+ else
10781+ registered = 1;
10782+
10783+ return ret;
10784 }
10785
10786 struct usb_function *gser_alloc(struct usb_function_instance *fi)
10787@@ -366,6 +1080,12 @@ struct usb_function *gser_alloc(struct usb_function_instance *fi)
10788
10789 opts = container_of(fi, struct f_serial_opts, func_inst);
10790
10791+#ifdef CONFIG_MODEM_SUPPORT
10792+ spin_lock_init(&gser->lock);
10793+#endif
10794+ if (nr_ports)
10795+ opts->port_num = gser_next_free_port++;
10796+
10797 gser->port_num = opts->port_num;
10798
10799 gser->port.func.name = "gser";
10800@@ -375,6 +1095,27 @@ struct usb_function *gser_alloc(struct usb_function_instance *fi)
10801 gser->port.func.set_alt = gser_set_alt;
10802 gser->port.func.disable = gser_disable;
10803 gser->port.func.free_func = gser_free;
10804+ gser->transport = gserial_ports[opts->port_num].transport;
10805+#ifdef CONFIG_MODEM_SUPPORT
10806+ /* We support only three ports for now */
10807+ if (opts->port_num == 0)
10808+ gser->port.func.name = "modem";
10809+ else if (opts->port_num == 1)
10810+ gser->port.func.name = "nmea";
10811+ else
10812+ gser->port.func.name = "modem2";
10813+ gser->port.func.setup = gser_setup;
10814+ gser->port.connect = gser_connect;
10815+ gser->port.get_dtr = gser_get_dtr;
10816+ gser->port.get_rts = gser_get_rts;
10817+ gser->port.send_carrier_detect = gser_send_carrier_detect;
10818+ gser->port.send_ring_indicator = gser_send_ring_indicator;
10819+ gser->port.send_modem_ctrl_bits = gser_send_modem_ctrl_bits;
10820+ gser->port.disconnect = gser_disconnect;
10821+ gser->port.send_break = gser_send_break;
10822+#endif
10823+ gserial_ports[gser->port_num].gser_ptr = gser;
10824+ gser_init();
10825
10826 return &gser->port.func;
10827 }
10828@@ -383,3 +1124,269 @@ DECLARE_USB_FUNCTION_INIT(gser, gser_alloc_inst, gser_alloc);
10829 MODULE_LICENSE("GPL");
10830 MODULE_AUTHOR("Al Borchers");
10831 MODULE_AUTHOR("David Brownell");
10832+
10833+/**
10834+ * gserial_init_port - bind a gserial_port to its transport
10835+ */
10836+int gserial_init_port(int port_num, const char *name,
10837+ const char *port_name)
10838+{
10839+ enum transport_type transport;
10840+ int ret = 0;
10841+
10842+ if (port_num >= GSERIAL_NO_PORTS)
10843+ return -ENODEV;
10844+
10845+ transport = str_to_xport(name);
10846+ pr_debug("%s, port:%d, transport:%s\n", __func__,
10847+ port_num, xport_to_str(transport));
10848+
10849+ gserial_ports[port_num].transport = transport;
10850+ gserial_ports[port_num].port_num = port_num;
10851+
10852+ switch (transport) {
10853+ case USB_GADGET_XPORT_TTY:
10854+ no_tty_ports++;
10855+ break;
10856+ case USB_GADGET_XPORT_SMD:
10857+ gserial_ports[port_num].client_port_num = no_smd_ports;
10858+ no_smd_ports++;
10859+ break;
10860+ case USB_GADGET_XPORT_HSIC:
10861+ ghsic_ctrl_set_port_name(port_name, name);
10862+ ghsic_data_set_port_name(port_name, name);
10863+
10864+ /*client port number will be updated in gport_setup*/
10865+ no_hsic_sports++;
10866+ break;
10867+ case USB_GADGET_XPORT_HSUART:
10868+ /*client port number will be updated in gport_setup*/
10869+ no_hsuart_sports++;
10870+ break;
10871+ default:
10872+ pr_err("%s: Un-supported transport transport: %u\n",
10873+ __func__, gserial_ports[port_num].transport);
10874+ return -ENODEV;
10875+ }
10876+
10877+ nr_ports++;
10878+
10879+ return ret;
10880+}
10881+
10882+
10883+bool gserial_is_connected(void)
10884+{
10885+ if (gserial_ports[0].gser_ptr != NULL)
10886+ return gserial_ports[0].gser_ptr->online;
10887+ return 0;
10888+}
10889+
10890+bool gserial_is_dun_w_softap_enabled(void)
10891+{
10892+ if (gserial_ports[0].gser_ptr != NULL)
10893+ return gserial_ports[0].dun_w_softap_enable;
10894+ return 0;
10895+}
10896+
10897+void gserial_dun_w_softap_enable(bool enable)
10898+{
10899+ pr_debug("android_usb: Setting dun_w_softap_enable to %u.",
10900+ enable);
10901+
10902+ gserial_ports[0].dun_w_softap_enable = enable;
10903+}
10904+
10905+bool gserial_is_dun_w_softap_active(void)
10906+{
10907+ if (gserial_ports[0].gser_ptr != NULL)
10908+ return gserial_ports[0].dun_w_softap_enable &&
10909+ gserial_ports[0].gser_ptr->online;
10910+ return 0;
10911+}
10912+
10913+static inline int gser_device_lock(atomic_t *excl)
10914+{
10915+ if (atomic_inc_return(excl) == 1) {
10916+ return 0;
10917+ } else {
10918+ atomic_dec(excl);
10919+ return -EBUSY;
10920+ }
10921+}
10922+
10923+static inline void gser_device_unlock(atomic_t *excl)
10924+{
10925+ atomic_dec(excl);
10926+}
10927+
10928+static int gser_open_dev(struct inode *ip, struct file *fp)
10929+{
10930+ struct f_gser *gser = gserial_ports[0].gser_ptr;
10931+
10932+ pr_debug("%s: Open serial device", __func__);
10933+
10934+ if (!gser) {
10935+ pr_err("%s: Serial device not created yet", __func__);
10936+ return -ENODEV;
10937+ }
10938+
10939+ if (gser_device_lock(&gser->open_excl)) {
10940+ pr_err("%s: Already opened", __func__);
10941+ return -EBUSY;
10942+ }
10943+
10944+ fp->private_data = gser;
10945+ pr_debug("%s: Serial device opened", __func__);
10946+
10947+ return 0;
10948+}
10949+
10950+static int gser_release_dev(struct inode *ip, struct file *fp)
10951+{
10952+ struct f_gser *gser = fp->private_data;
10953+
10954+ pr_debug("%s: Close serial device", __func__);
10955+
10956+ if (!gser) {
10957+ pr_err("Serial device not created yet\n");
10958+ return -ENODEV;
10959+ }
10960+
10961+ gser_device_unlock(&gser->open_excl);
10962+
10963+ return 0;
10964+}
10965+
10966+static void gser_ioctl_set_transport(struct f_gser *gser,
10967+ unsigned int transport)
10968+{
10969+ int ret;
10970+ enum transport_type new_transport;
10971+ const struct usb_endpoint_descriptor *ep_in_desc_backup;
10972+ const struct usb_endpoint_descriptor *ep_out_desc_backup;
10973+
10974+ if (transport == GSERIAL_SET_XPORT_TYPE_TTY) {
10975+ new_transport = USB_GADGET_XPORT_TTY;
10976+ pr_debug("%s: Switching modem transport to TTY.", __func__);
10977+ gser->port.flags |= ASYNC_LOW_LATENCY;
10978+ } else if (transport == GSERIAL_SET_XPORT_TYPE_SMD) {
10979+ new_transport = USB_GADGET_XPORT_SMD;
10980+ pr_debug("%s: Switching modem transport to SMD.", __func__);
10981+ } else {
10982+ pr_err("%s: Wrong transport type %d", __func__, transport);
10983+ return;
10984+ }
10985+
10986+ if (gser->transport == new_transport) {
10987+ pr_debug("%s: Modem transport aready set to this type.",
10988+ __func__);
10989+ return;
10990+ }
10991+
10992+ ep_in_desc_backup = gser->port.in->desc;
10993+ ep_out_desc_backup = gser->port.out->desc;
10994+ gport_disconnect(gser);
10995+ if (new_transport == USB_GADGET_XPORT_TTY) {
10996+ ret = gserial_alloc_line(
10997+ &gserial_ports[gser->port_num].client_port_num);
10998+ if (ret)
10999+ pr_debug("%s: Unable to alloc TTY line", __func__);
11000+ }
11001+
11002+ gser->port.in->desc = ep_in_desc_backup;
11003+ gser->port.out->desc = ep_out_desc_backup;
11004+ gser->transport = new_transport;
11005+ gport_connect(gser);
11006+ pr_debug("%s: Modem transport switch is complete.", __func__);
11007+
11008+}
11009+
11010+static long gser_ioctl(struct file *fp, unsigned cmd, unsigned long arg)
11011+{
11012+ int ret = 0;
11013+ int count;
11014+ int xport_type;
11015+ int smd_port_num;
11016+ char smd_write_buf[GSERIAL_BUF_LEN];
11017+ struct ioctl_smd_write_arg_type smd_write_arg;
11018+ struct f_gser *gser;
11019+ void __user *argp = (void __user *)arg;
11020+
11021+ if (!fp || !fp->private_data) {
11022+ pr_err("%s: Invalid file handle", __func__);
11023+ return -EBADFD;
11024+ }
11025+
11026+ gser = fp->private_data;
11027+ pr_debug("Received command %d", cmd);
11028+
11029+ if (gser_device_lock(&gser->ioctl_excl))
11030+ return -EBUSY;
11031+
11032+ switch (cmd) {
11033+ case GSERIAL_SET_XPORT_TYPE:
11034+ if (copy_from_user(&xport_type, argp, sizeof(xport_type))) {
11035+ pr_err("%s: failed to copy IOCTL set transport type",
11036+ __func__);
11037+ ret = -EFAULT;
11038+ break;
11039+ }
11040+
11041+ gser_ioctl_set_transport(gser, xport_type);
11042+ break;
11043+
11044+ case GSERIAL_SMD_WRITE:
11045+ if (gser->transport != USB_GADGET_XPORT_SMD) {
11046+ pr_err("%s: ERR: Got SMD WR cmd when not in SMD mode",
11047+ __func__);
11048+
11049+ break;
11050+ }
11051+
11052+ pr_debug("%s: Copy GSERIAL_SMD_WRITE IOCTL command argument",
11053+ __func__);
11054+ if (copy_from_user(&smd_write_arg, argp,
11055+ sizeof(smd_write_arg))) {
11056+ ret = -EFAULT;
11057+
11058+ pr_err("%s: failed to copy IOCTL GSERIAL_SMD_WRITE arg",
11059+ __func__);
11060+
11061+ break;
11062+ }
11063+ smd_port_num =
11064+ gserial_ports[gser->port_num].client_port_num;
11065+
11066+ pr_debug("%s: Copying %d bytes from user buffer to local\n",
11067+ __func__, smd_write_arg.size);
11068+
11069+ if (copy_from_user(smd_write_buf, smd_write_arg.buf,
11070+ smd_write_arg.size)) {
11071+
11072+ pr_err("%s: failed to copy buf for GSERIAL_SMD_WRITE",
11073+ __func__);
11074+
11075+ ret = -EFAULT;
11076+ break;
11077+ }
11078+
11079+ pr_debug("%s: Writing %d bytes to SMD channel\n",
11080+ __func__, smd_write_arg.size);
11081+
11082+ count = gsmd_write(smd_port_num, smd_write_buf,
11083+ smd_write_arg.size);
11084+
11085+ if (count != smd_write_arg.size)
11086+ ret = -EFAULT;
11087+
11088+ break;
11089+ default:
11090+ pr_err("Unsupported IOCTL");
11091+ ret = -EINVAL;
11092+ }
11093+
11094+ gser_device_unlock(&gser->ioctl_excl);
11095+ return ret;
11096+}
11097+
11098diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
11099index 693f0c2..fb2b81d 100644
11100--- a/drivers/usb/gadget/rndis.c
11101+++ b/drivers/usb/gadget/rndis.c
11102@@ -35,7 +35,7 @@
11103 #include <asm/io.h>
11104 #include <asm/byteorder.h>
11105 #include <asm/unaligned.h>
11106-
11107+#include "u_bam_data.h"
11108
11109 #undef VERBOSE_DEBUG
11110
11111@@ -59,6 +59,16 @@ MODULE_PARM_DESC (rndis_debug, "enable debugging");
11112
11113 #define RNDIS_MAX_CONFIGS 1
11114
11115+int rndis_ul_max_pkt_per_xfer_rcvd;
11116+module_param(rndis_ul_max_pkt_per_xfer_rcvd, int, S_IRUGO);
11117+MODULE_PARM_DESC(rndis_ul_max_pkt_per_xfer_rcvd,
11118+ "Max num of REMOTE_NDIS_PACKET_MSGs received in a single transfer");
11119+
11120+int rndis_ul_max_xfer_size_rcvd;
11121+module_param(rndis_ul_max_xfer_size_rcvd, int, S_IRUGO);
11122+MODULE_PARM_DESC(rndis_ul_max_xfer_size_rcvd,
11123+ "Max size of bus transfer received");
11124+
11125
11126 static rndis_params rndis_per_dev_params[RNDIS_MAX_CONFIGS];
11127
11128@@ -534,14 +544,11 @@ static int gen_ndis_set_resp(u8 configNr, u32 OID, u8 *buf, u32 buf_len,
11129 */
11130 retval = 0;
11131 if (*params->filter) {
11132- params->state = RNDIS_DATA_INITIALIZED;
11133- netif_carrier_on(params->dev);
11134- if (netif_running(params->dev))
11135- netif_wake_queue(params->dev);
11136+ pr_debug("%s(): disable flow control\n", __func__);
11137+ rndis_flow_control(configNr, false);
11138 } else {
11139- params->state = RNDIS_INITIALIZED;
11140- netif_carrier_off(params->dev);
11141- netif_stop_queue(params->dev);
11142+ pr_debug("%s(): enable flow control\n", __func__);
11143+ rndis_flow_control(configNr, true);
11144 }
11145 break;
11146
11147@@ -585,16 +592,17 @@ static int rndis_init_response(int configNr, rndis_init_msg_type *buf)
11148 resp->MinorVersion = cpu_to_le32(RNDIS_MINOR_VERSION);
11149 resp->DeviceFlags = cpu_to_le32(RNDIS_DF_CONNECTIONLESS);
11150 resp->Medium = cpu_to_le32(RNDIS_MEDIUM_802_3);
11151- resp->MaxPacketsPerTransfer = cpu_to_le32(1);
11152- resp->MaxTransferSize = cpu_to_le32(
11153- params->dev->mtu
11154+ resp->MaxPacketsPerTransfer = cpu_to_le32(params->max_pkt_per_xfer);
11155+ resp->MaxTransferSize = cpu_to_le32(params->max_pkt_per_xfer *
11156+ (params->dev->mtu
11157 + sizeof(struct ethhdr)
11158 + sizeof(struct rndis_packet_msg_type)
11159- + 22);
11160- resp->PacketAlignmentFactor = cpu_to_le32(0);
11161+ + 22));
11162+ resp->PacketAlignmentFactor = cpu_to_le32(params->pkt_alignment_factor);
11163 resp->AFListOffset = cpu_to_le32(0);
11164 resp->AFListSize = cpu_to_le32(0);
11165
11166+ params->ul_max_xfer_size = le32_to_cpu(resp->MaxTransferSize);
11167 params->resp_avail(params->v);
11168 return 0;
11169 }
11170@@ -686,6 +694,12 @@ static int rndis_reset_response(int configNr, rndis_reset_msg_type *buf)
11171 rndis_reset_cmplt_type *resp;
11172 rndis_resp_t *r;
11173 struct rndis_params *params = rndis_per_dev_params + configNr;
11174+ u32 length;
11175+ u8 *xbuf;
11176+
11177+ /* drain the response queue */
11178+ while ((xbuf = rndis_get_next_response(configNr, &length)))
11179+ rndis_free_response(configNr, xbuf);
11180
11181 r = rndis_add_response(configNr, sizeof(rndis_reset_cmplt_type));
11182 if (!r)
11183@@ -794,7 +808,7 @@ void rndis_set_host_mac(int configNr, const u8 *addr)
11184 */
11185 int rndis_msg_parser(u8 configNr, u8 *buf)
11186 {
11187- u32 MsgType, MsgLength;
11188+ u32 MsgType, MsgLength, major, minor, max_transfer_size;
11189 __le32 *tmp;
11190 struct rndis_params *params;
11191
11192@@ -819,6 +833,19 @@ int rndis_msg_parser(u8 configNr, u8 *buf)
11193 case RNDIS_MSG_INIT:
11194 pr_debug("%s: RNDIS_MSG_INIT\n",
11195 __func__);
11196+ tmp++; /* to get RequestID */
11197+ major = get_unaligned_le32(tmp++);
11198+ minor = get_unaligned_le32(tmp++);
11199+ max_transfer_size = get_unaligned_le32(tmp++);
11200+
11201+ params->host_rndis_major_ver = major;
11202+ params->host_rndis_minor_ver = minor;
11203+ params->dl_max_xfer_size = max_transfer_size;
11204+
11205+ pr_debug("%s(): RNDIS Host Major:%d Minor:%d version\n",
11206+ __func__, major, minor);
11207+ pr_debug("%s(): UL Max Transfer size:%x\n", __func__,
11208+ max_transfer_size);
11209 params->state = RNDIS_INITIALIZED;
11210 return rndis_init_response(configNr,
11211 (rndis_init_msg_type *)buf);
11212@@ -826,11 +853,17 @@ int rndis_msg_parser(u8 configNr, u8 *buf)
11213 case RNDIS_MSG_HALT:
11214 pr_debug("%s: RNDIS_MSG_HALT\n",
11215 __func__);
11216- params->state = RNDIS_UNINITIALIZED;
11217- if (params->dev) {
11218- netif_carrier_off(params->dev);
11219- netif_stop_queue(params->dev);
11220+
11221+ if (!is_rndis_ipa_supported()) {
11222+ if (params->dev) {
11223+ netif_carrier_off(params->dev);
11224+ netif_stop_queue(params->dev);
11225+ }
11226+ } else {
11227+ if (params->state == RNDIS_DATA_INITIALIZED)
11228+ u_bam_data_stop_rndis_ipa();
11229 }
11230+ params->state = RNDIS_UNINITIALIZED;
11231 return 0;
11232
11233 case RNDIS_MSG_QUERY:
11234@@ -883,6 +916,8 @@ int rndis_register(void (*resp_avail)(void *v), void *v)
11235 rndis_per_dev_params[i].used = 1;
11236 rndis_per_dev_params[i].resp_avail = resp_avail;
11237 rndis_per_dev_params[i].v = v;
11238+ rndis_per_dev_params[i].max_pkt_per_xfer = 1;
11239+ rndis_per_dev_params[i].pkt_alignment_factor = 0;
11240 pr_debug("%s: configNr = %d\n", __func__, i);
11241 return i;
11242 }
11243@@ -910,6 +945,10 @@ int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
11244 rndis_per_dev_params[configNr].dev = dev;
11245 rndis_per_dev_params[configNr].filter = cdc_filter;
11246
11247+ /* reset aggregation stats for every set_alt */
11248+ rndis_ul_max_xfer_size_rcvd = 0;
11249+ rndis_ul_max_pkt_per_xfer_rcvd = 0;
11250+
11251 return 0;
11252 }
11253
11254@@ -935,6 +974,67 @@ int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)
11255
11256 return 0;
11257 }
11258+u32 rndis_get_dl_max_xfer_size(u8 configNr)
11259+{
11260+ pr_debug("%s:\n", __func__);
11261+ return rndis_per_dev_params[configNr].dl_max_xfer_size;
11262+}
11263+
11264+u32 rndis_get_ul_max_xfer_size(u8 configNr)
11265+{
11266+ pr_debug("%s:\n", __func__);
11267+ return rndis_per_dev_params[configNr].ul_max_xfer_size;
11268+}
11269+
11270+void rndis_set_max_pkt_xfer(u8 configNr, u8 max_pkt_per_xfer)
11271+{
11272+ pr_debug("%s:\n", __func__);
11273+
11274+ rndis_per_dev_params[configNr].max_pkt_per_xfer = max_pkt_per_xfer;
11275+}
11276+
11277+void rndis_set_pkt_alignment_factor(u8 configNr, u8 pkt_alignment_factor)
11278+{
11279+ pr_debug("%s:\n", __func__);
11280+
11281+ rndis_per_dev_params[configNr].pkt_alignment_factor =
11282+ pkt_alignment_factor;
11283+}
11284+/**
11285+ * rndis_flow_control: enable/disable flow control with USB RNDIS interface
11286+ * confignr - RNDIS network interface number
11287+ * enable_flow_control - true: perform flow control, false: disable flow control
11288+ *
11289+ * In BAM2BAM IPA mode, this function triggers functionality to start/stop
11290+ * endless transfers, otherwise it enables/disables RNDIS network interface.
11291+ */
11292+void rndis_flow_control(u8 confignr, bool enable_flow_control)
11293+{
11294+ struct rndis_params *params;
11295+
11296+ params = &rndis_per_dev_params[confignr];
11297+ pr_debug("%s(): params->state:%x\n", __func__, params->state);
11298+ if (enable_flow_control) {
11299+ if (is_rndis_ipa_supported()) {
11300+ if (params->state == RNDIS_DATA_INITIALIZED)
11301+ u_bam_data_stop_rndis_ipa();
11302+ } else {
11303+ netif_carrier_off(params->dev);
11304+ netif_stop_queue(params->dev);
11305+ }
11306+ params->state = RNDIS_INITIALIZED;
11307+ } else {
11308+ if (is_rndis_ipa_supported()) {
11309+ if (params->state != RNDIS_DATA_INITIALIZED)
11310+ u_bam_data_start_rndis_ipa();
11311+ } else {
11312+ netif_carrier_on(params->dev);
11313+ if (netif_running(params->dev))
11314+ netif_wake_queue(params->dev);
11315+ }
11316+ params->state = RNDIS_DATA_INITIALIZED;
11317+ }
11318+}
11319
11320 void rndis_add_hdr(struct sk_buff *skb)
11321 {
11322@@ -954,25 +1054,33 @@ void rndis_free_response(int configNr, u8 *buf)
11323 {
11324 rndis_resp_t *r;
11325 struct list_head *act, *tmp;
11326+ unsigned long flags;
11327
11328+ spin_lock_irqsave(&rndis_per_dev_params[configNr].lock, flags);
11329 list_for_each_safe(act, tmp,
11330 &(rndis_per_dev_params[configNr].resp_queue))
11331 {
11332+ if (!act)
11333+ continue;
11334+
11335 r = list_entry(act, rndis_resp_t, list);
11336 if (r && r->buf == buf) {
11337 list_del(&r->list);
11338 kfree(r);
11339 }
11340 }
11341+ spin_unlock_irqrestore(&rndis_per_dev_params[configNr].lock, flags);
11342 }
11343
11344 u8 *rndis_get_next_response(int configNr, u32 *length)
11345 {
11346 rndis_resp_t *r;
11347 struct list_head *act, *tmp;
11348+ unsigned long flags;
11349
11350 if (!length) return NULL;
11351
11352+ spin_lock_irqsave(&rndis_per_dev_params[configNr].lock, flags);
11353 list_for_each_safe(act, tmp,
11354 &(rndis_per_dev_params[configNr].resp_queue))
11355 {
11356@@ -980,9 +1088,12 @@ u8 *rndis_get_next_response(int configNr, u32 *length)
11357 if (!r->send) {
11358 r->send = 1;
11359 *length = r->length;
11360+ spin_unlock_irqrestore(
11361+ &rndis_per_dev_params[configNr].lock, flags);
11362 return r->buf;
11363 }
11364 }
11365+ spin_unlock_irqrestore(&rndis_per_dev_params[configNr].lock, flags);
11366
11367 return NULL;
11368 }
11369@@ -990,6 +1101,7 @@ u8 *rndis_get_next_response(int configNr, u32 *length)
11370 static rndis_resp_t *rndis_add_response(int configNr, u32 length)
11371 {
11372 rndis_resp_t *r;
11373+ unsigned long flags;
11374
11375 /* NOTE: this gets copied into ether.c USB_BUFSIZ bytes ... */
11376 r = kmalloc(sizeof(rndis_resp_t) + length, GFP_ATOMIC);
11377@@ -999,8 +1111,10 @@ static rndis_resp_t *rndis_add_response(int configNr, u32 length)
11378 r->length = length;
11379 r->send = 0;
11380
11381+ spin_lock_irqsave(&rndis_per_dev_params[configNr].lock, flags);
11382 list_add_tail(&r->list,
11383 &(rndis_per_dev_params[configNr].resp_queue));
11384+ spin_unlock_irqrestore(&rndis_per_dev_params[configNr].lock, flags);
11385 return r;
11386 }
11387
11388@@ -1008,25 +1122,72 @@ int rndis_rm_hdr(struct gether *port,
11389 struct sk_buff *skb,
11390 struct sk_buff_head *list)
11391 {
11392- /* tmp points to a struct rndis_packet_msg_type */
11393- __le32 *tmp = (void *)skb->data;
11394+ int num_pkts = 0;
11395
11396- /* MessageType, MessageLength */
11397- if (cpu_to_le32(RNDIS_MSG_PACKET)
11398- != get_unaligned(tmp++)) {
11399- dev_kfree_skb_any(skb);
11400- return -EINVAL;
11401- }
11402- tmp++;
11403+ if (skb->len > rndis_ul_max_xfer_size_rcvd)
11404+ rndis_ul_max_xfer_size_rcvd = skb->len;
11405+
11406+ while (skb->len) {
11407+ struct rndis_packet_msg_type *hdr;
11408+ struct sk_buff *skb2;
11409+ u32 msg_len, data_offset, data_len;
11410+
11411+ if (skb->len < sizeof *hdr) {
11412+ pr_err("invalid rndis pkt: skblen:%u hdr_len:%zu",
11413+ skb->len, sizeof *hdr);
11414+ dev_kfree_skb_any(skb);
11415+ return -EINVAL;
11416+ }
11417+
11418+ hdr = (void *)skb->data;
11419+ msg_len = le32_to_cpu(hdr->MessageLength);
11420+ data_offset = le32_to_cpu(hdr->DataOffset);
11421+ data_len = le32_to_cpu(hdr->DataLength);
11422+
11423+ if (skb->len < msg_len ||
11424+ ((data_offset + data_len + 8) > msg_len)) {
11425+ pr_err("invalid rndis message: %d/%d/%d/%d, len:%d\n",
11426+ le32_to_cpu(hdr->MessageType),
11427+ msg_len, data_offset, data_len, skb->len);
11428+ dev_kfree_skb_any(skb);
11429+ return -EOVERFLOW;
11430+ }
11431+
11432+ if (le32_to_cpu(hdr->MessageType) != RNDIS_MSG_PACKET) {
11433+ pr_err("invalid rndis message: %d/%d/%d/%d, len:%d\n",
11434+ le32_to_cpu(hdr->MessageType),
11435+ msg_len, data_offset, data_len, skb->len);
11436+ dev_kfree_skb_any(skb);
11437+ return -EINVAL;
11438+ }
11439
11440- /* DataOffset, DataLength */
11441- if (!skb_pull(skb, get_unaligned_le32(tmp++) + 8)) {
11442- dev_kfree_skb_any(skb);
11443- return -EOVERFLOW;
11444+ num_pkts++;
11445+
11446+ skb_pull(skb, data_offset + 8);
11447+
11448+ if (data_len == skb->len ||
11449+ data_len == (skb->len - 1)) {
11450+ skb_trim(skb, data_len);
11451+ break;
11452+ }
11453+
11454+ skb2 = skb_clone(skb, GFP_ATOMIC);
11455+ if (!skb2) {
11456+ pr_err("%s:skb clone failed\n", __func__);
11457+ dev_kfree_skb_any(skb);
11458+ return -ENOMEM;
11459+ }
11460+
11461+ skb_pull(skb, msg_len - sizeof *hdr);
11462+ skb_trim(skb2, data_len);
11463+ skb_queue_tail(list, skb2);
11464 }
11465- skb_trim(skb, get_unaligned_le32(tmp++));
11466+
11467+ if (num_pkts > rndis_ul_max_pkt_per_xfer_rcvd)
11468+ rndis_ul_max_pkt_per_xfer_rcvd = num_pkts;
11469
11470 skb_queue_tail(list, skb);
11471+
11472 return 0;
11473 }
11474
11475@@ -1044,7 +1205,10 @@ static int rndis_proc_show(struct seq_file *m, void *v)
11476 "speed : %d\n"
11477 "cable : %s\n"
11478 "vendor ID : 0x%08X\n"
11479- "vendor : %s\n",
11480+ "vendor : %s\n"
11481+ "ul-max-xfer-size:%zu max-xfer-size-rcvd: %d\n"
11482+ "ul-max-pkts-per-xfer:%d max-pkts-per-xfer-rcvd:%d\n"
11483+ "pkt_alignment_factor:%d\n",
11484 param->confignr, (param->used) ? "y" : "n",
11485 ({ char *s = "?";
11486 switch (param->state) {
11487@@ -1058,7 +1222,14 @@ static int rndis_proc_show(struct seq_file *m, void *v)
11488 param->medium,
11489 (param->media_state) ? 0 : param->speed*100,
11490 (param->media_state) ? "disconnected" : "connected",
11491- param->vendorID, param->vendorDescr);
11492+ param->vendorID, param->vendorDescr,
11493+ param->max_pkt_per_xfer *
11494+ (param->dev->mtu + sizeof(struct ethhdr) +
11495+ sizeof(struct rndis_packet_msg_type) + 22),
11496+ rndis_ul_max_xfer_size_rcvd,
11497+ param->max_pkt_per_xfer,
11498+ rndis_ul_max_pkt_per_xfer_rcvd,
11499+ param->pkt_alignment_factor);
11500 return 0;
11501 }
11502
11503@@ -1154,9 +1325,11 @@ int rndis_init(void)
11504 return -EIO;
11505 }
11506 #endif
11507+ spin_lock_init(&(rndis_per_dev_params[i].lock));
11508 rndis_per_dev_params[i].confignr = i;
11509 rndis_per_dev_params[i].used = 0;
11510 rndis_per_dev_params[i].state = RNDIS_UNINITIALIZED;
11511+ rndis_per_dev_params[i].pkt_alignment_factor = 0;
11512 rndis_per_dev_params[i].media_state
11513 = RNDIS_MEDIA_STATE_DISCONNECTED;
11514 INIT_LIST_HEAD(&(rndis_per_dev_params[i].resp_queue));
11515diff --git a/drivers/usb/gadget/rndis.h b/drivers/usb/gadget/rndis.h
11516index 0647f2f..c48a057 100644
11517--- a/drivers/usb/gadget/rndis.h
11518+++ b/drivers/usb/gadget/rndis.h
11519@@ -189,10 +189,17 @@ typedef struct rndis_params
11520 struct net_device *dev;
11521
11522 u32 vendorID;
11523+ u8 max_pkt_per_xfer;
11524+ u8 pkt_alignment_factor;
11525 const char *vendorDescr;
11526 void (*resp_avail)(void *v);
11527 void *v;
11528 struct list_head resp_queue;
11529+ spinlock_t lock;
11530+ u32 host_rndis_major_ver;
11531+ u32 host_rndis_minor_ver;
11532+ u32 ul_max_xfer_size;
11533+ u32 dl_max_xfer_size;
11534 } rndis_params;
11535
11536 /* RNDIS Message parser and other useless functions */
11537@@ -204,6 +211,9 @@ int rndis_set_param_dev (u8 configNr, struct net_device *dev,
11538 int rndis_set_param_vendor (u8 configNr, u32 vendorID,
11539 const char *vendorDescr);
11540 int rndis_set_param_medium (u8 configNr, u32 medium, u32 speed);
11541+void rndis_set_max_pkt_xfer(u8 configNr, u8 max_pkt_per_xfer);
11542+u32 rndis_get_ul_max_xfer_size(u8 configNr);
11543+u32 rndis_get_dl_max_xfer_size(u8 configNr);
11544 void rndis_add_hdr (struct sk_buff *skb);
11545 int rndis_rm_hdr(struct gether *port, struct sk_buff *skb,
11546 struct sk_buff_head *list);
11547@@ -215,8 +225,8 @@ int rndis_signal_connect (int configNr);
11548 int rndis_signal_disconnect (int configNr);
11549 int rndis_state (int configNr);
11550 extern void rndis_set_host_mac (int configNr, const u8 *addr);
11551-
11552+extern bool is_rndis_ipa_supported(void);
11553 int rndis_init(void);
11554 void rndis_exit (void);
11555-
11556+void rndis_flow_control(u8 confignr, bool enable_flow_control);
11557 #endif /* _LINUX_RNDIS_H */
11558diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
11559index 09275cc..9835254 100644
11560--- a/drivers/usb/gadget/storage_common.c
11561+++ b/drivers/usb/gadget/storage_common.c
11562@@ -169,6 +169,9 @@ static inline struct fsg_lun *fsg_lun_from_dev(struct device *dev)
11563 #define EP0_BUFSIZE 256
11564 #define DELAYED_STATUS (EP0_BUFSIZE + 999) /* An impossibly large value */
11565
11566+#ifdef CONFIG_USB_CSW_HACK
11567+#define fsg_num_buffers 4
11568+#else
11569 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
11570
11571 static unsigned int fsg_num_buffers = CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS;
11572@@ -184,6 +187,7 @@ MODULE_PARM_DESC(num_buffers, "Number of pipeline buffers");
11573 #define fsg_num_buffers CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS
11574
11575 #endif /* CONFIG_USB_DEBUG */
11576+#endif /* CONFIG_USB_CSW_HACK */
11577
11578 /* check if fsg_num_buffers is within a valid range */
11579 static inline int fsg_num_buffers_validate(void)
11580@@ -434,17 +438,6 @@ static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
11581 unsigned int blkbits;
11582 unsigned int blksize;
11583
11584-
11585- if (filename) {
11586- int len = strlen(filename);
11587- if ((len > 3) &&
11588- (!strcmp(filename + (len - 3), "ISO") ||
11589- !strcmp(filename + (len - 3), "iso")))
11590- curlun->cdrom = 1;
11591- else
11592- curlun->cdrom = 0;
11593- }
11594-
11595 /* R/W if we can, R/O if we must */
11596 ro = curlun->initially_ro;
11597 if (!ro) {
11598@@ -579,15 +572,6 @@ static ssize_t fsg_show_ro(struct device *dev, struct device_attribute *attr,
11599 : curlun->initially_ro);
11600 }
11601
11602-static ssize_t fsg_show_cdrom(struct device *dev,
11603- struct device_attribute *attr, char *buf)
11604-{
11605- struct fsg_lun *curlun = fsg_lun_from_dev(dev);
11606-
11607- return sprintf(buf, "%d\n", curlun->cdrom);
11608-}
11609-
11610-
11611 static ssize_t fsg_show_nofua(struct device *dev, struct device_attribute *attr,
11612 char *buf)
11613 {
11614@@ -596,38 +580,6 @@ static ssize_t fsg_show_nofua(struct device *dev, struct device_attribute *attr,
11615 return sprintf(buf, "%u\n", curlun->nofua);
11616 }
11617
11618-
11619-static ssize_t fsg_store_cdrom(struct device *dev,
11620- struct device_attribute *attr,
11621- const char *buf, size_t count)
11622-{
11623- ssize_t rc;
11624- struct fsg_lun *curlun = fsg_lun_from_dev(dev);
11625- struct rw_semaphore *filesem = dev_get_drvdata(dev);
11626- unsigned cdrom;
11627-
11628- rc = kstrtouint(buf, 2, &cdrom);
11629- if (rc)
11630- return rc;
11631-
11632- /*
11633- * Allow the write-enable status to change only while the
11634- * backing file is closed.
11635- */
11636- down_read(filesem);
11637- if (fsg_lun_is_open(curlun)) {
11638- LDBG(curlun, "cdrom status change prevented\n");
11639- rc = -EBUSY;
11640- } else {
11641- curlun->cdrom = cdrom;
11642- LDBG(curlun, "cdrom status set to %d\n", curlun->cdrom);
11643- rc = count;
11644- }
11645- up_read(filesem);
11646- return rc;
11647-}
11648-
11649-
11650 #ifdef CONFIG_USB_MSC_PROFILING
11651 static ssize_t fsg_show_perf(struct device *dev, struct device_attribute *attr,
11652 char *buf)
11653@@ -680,6 +632,9 @@ static ssize_t fsg_show_file(struct device *dev, struct device_attribute *attr,
11654 rc = PTR_ERR(p);
11655 else {
11656 rc = strlen(p);
11657+ if (rc > PAGE_SIZE - 2)
11658+ rc = PAGE_SIZE - 2;
11659+
11660 memmove(buf, p, rc);
11661 buf[rc] = '\n'; /* Add a newline */
11662 buf[++rc] = 0;
11663@@ -751,10 +706,16 @@ static ssize_t fsg_store_file(struct device *dev, struct device_attribute *attr,
11664 struct rw_semaphore *filesem = dev_get_drvdata(dev);
11665 int rc = 0;
11666
11667+
11668+#if !defined(CONFIG_USB_G_ANDROID)
11669+ /* disabled in android because we need to allow closing the backing file
11670+ * if the media was removed
11671+ */
11672 if (curlun->prevent_medium_removal && fsg_lun_is_open(curlun)) {
11673 LDBG(curlun, "eject attempt prevented\n");
11674 return -EBUSY; /* "Door is locked" */
11675 }
11676+#endif
11677
11678 /* Remove a trailing newline */
11679 if (count > 0 && buf[count-1] == '\n')
11680diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
11681index 4b3602f..96276dd 100644
11682--- a/drivers/usb/gadget/u_ether.c
11683+++ b/drivers/usb/gadget/u_ether.c
11684@@ -18,11 +18,15 @@
11685 #include <linux/gfp.h>
11686 #include <linux/device.h>
11687 #include <linux/ctype.h>
11688+#include <linux/if_arp.h>
11689 #include <linux/etherdevice.h>
11690 #include <linux/ethtool.h>
11691 #include <linux/if_vlan.h>
11692-#include <linux/brcm_console.h>
11693-
11694+#include <linux/msm_rmnet.h>
11695+#include <linux/debugfs.h>
11696+#include <linux/seq_file.h>
11697+#include <linux/notifier.h>
11698+#include <linux/cpufreq.h>
11699 #include "u_ether.h"
11700
11701
11702@@ -49,82 +53,34 @@
11703
11704 #define UETH__VERSION "29-May-2008"
11705
11706-#ifdef CONFIG_BRCM_NETCONSOLE
11707-
11708-#define USB_EVENTQUEUE_SIZE 4
11709+static struct workqueue_struct *uether_wq;
11710+static struct workqueue_struct *uether_tx_wq;
11711
11712-struct usb_event_queue_t {
11713- uint32_t in_index;
11714- uint32_t out_index;
11715- uint32_t is_empty;
11716- spinlock_t usbevent_lock;
11717- uint32_t event[USB_EVENTQUEUE_SIZE];
11718-};
11719+static int tx_start_threshold = 1500;
11720+module_param(tx_start_threshold, uint, S_IRUGO | S_IWUSR);
11721+MODULE_PARM_DESC(tx_start_threshold,
11722+ "Threashold to start stopped network queue");
11723
11724-static uint32_t queue_usbevent(struct usb_event_queue_t *queue, uint32_t event);
11725-static uint32_t dequeue_usbevent(struct usb_event_queue_t *queue, uint32_t *pevent);
11726-static uint32_t usb_eventqueue_init(struct usb_event_queue_t *queue);
11727+static int tx_stop_threshold = 2000;
11728+module_param(tx_stop_threshold, uint, S_IRUGO | S_IWUSR);
11729+MODULE_PARM_DESC(tx_stop_threshold,
11730+ "Threashold to stop network queue");
11731
11732-static uint32_t usb_eventqueue_init(struct usb_event_queue_t *queue)
11733-{
11734- spin_lock_init(&queue->usbevent_lock);
11735- queue->in_index = 0;
11736- queue->out_index = 0;
11737- queue->is_empty = 1;
11738- return 1;
11739-}
11740+static unsigned int min_cpu_freq;
11741+module_param(min_cpu_freq, uint, S_IRUGO | S_IWUSR);
11742+MODULE_PARM_DESC(min_cpu_freq,
11743+ "to set minimum cpu frquency to when ethernet ifc is active");
11744
11745-static uint32_t is_queue_empty(struct usb_event_queue_t *queue)
11746-{
11747- if ((queue->in_index == queue->out_index) && (queue->is_empty))
11748- return 1;
11749- else
11750- return 0;
11751-}
11752-static uint32_t is_queue_full(struct usb_event_queue_t *queue)
11753-{
11754- if ((queue->in_index == queue->out_index) && (!queue->is_empty))
11755- return 1;
11756- else
11757- return 0;
11758-}
11759-
11760-static uint32_t queue_usbevent(struct usb_event_queue_t *queue, uint32_t event)
11761-{
11762- unsigned long flags;
11763- spin_lock_irqsave(&queue->usbevent_lock, flags);
11764- if (is_queue_full(queue)) {
11765- spin_unlock_irqrestore(&queue->usbevent_lock, flags);
11766- return 0;
11767- }
11768- queue->event[queue->in_index++] = event;
11769- if (queue->in_index >= USB_EVENTQUEUE_SIZE) {
11770- queue->in_index = 0;
11771- }
11772- queue->is_empty = 0;
11773- spin_unlock_irqrestore(&queue->usbevent_lock, flags);
11774- return 1;
11775-}
11776+/* this refers to max number sgs per transfer
11777+ * which includes headers/data packets
11778+ */
11779+#define DL_MAX_PKTS_PER_XFER 20
11780
11781-static uint32_t dequeue_usbevent(struct usb_event_queue_t *queue, uint32_t *pevent)
11782-{
11783- unsigned long flags;
11784- spin_lock_irqsave(&queue->usbevent_lock, flags);
11785- if (is_queue_empty(queue)) {
11786- spin_unlock_irqrestore(&queue->usbevent_lock, flags);
11787- return 0;
11788- }
11789- *pevent = queue->event[queue->out_index++];
11790- if (queue->out_index >= USB_EVENTQUEUE_SIZE) {
11791- queue->out_index = 0;
11792- }
11793- if (queue->out_index == queue->in_index) {
11794- queue->is_empty = 1;
11795- }
11796- spin_unlock_irqrestore(&queue->usbevent_lock, flags);
11797- return 1;
11798-}
11799-#endif
11800+enum ifc_state {
11801+ ETH_UNDEFINED,
11802+ ETH_STOP,
11803+ ETH_START,
11804+};
11805
11806 struct eth_dev {
11807 /* lock is held while accessing port_usb
11808@@ -135,195 +91,90 @@ struct eth_dev {
11809 struct net_device *net;
11810 struct usb_gadget *gadget;
11811
11812- spinlock_t req_lock
11813-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
11814- , req_rx_lock
11815-#endif
11816- ; /* guard {rx,tx}_reqs */
11817+ spinlock_t req_lock; /* guard {rx,tx}_reqs */
11818 struct list_head tx_reqs, rx_reqs;
11819- atomic_t tx_qlen;
11820+ unsigned tx_qlen;
11821+/* Minimum number of TX USB request queued to UDC */
11822+#define TX_REQ_THRESHOLD 5
11823+ int no_tx_req_used;
11824+ int tx_skb_hold_count;
11825+ u32 tx_req_bufsize;
11826+ struct sk_buff_head tx_skb_q;
11827
11828 struct sk_buff_head rx_frames;
11829
11830 unsigned header_len;
11831+ unsigned int ul_max_pkts_per_xfer;
11832+ unsigned int dl_max_pkts_per_xfer;
11833+ uint32_t dl_max_xfer_size;
11834+ bool rx_trigger_enabled;
11835 struct sk_buff *(*wrap)(struct gether *, struct sk_buff *skb);
11836 int (*unwrap)(struct gether *,
11837 struct sk_buff *skb,
11838 struct sk_buff_head *list);
11839
11840 struct work_struct work;
11841-#ifdef CONFIG_BRCM_NETCONSOLE
11842- struct usb_event_queue_t usbevent_queue;
11843-#endif
11844-
11845-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
11846- struct workqueue_struct *rx_workqueue;
11847- unsigned char *skb_data;
11848-#endif
11849+ struct work_struct rx_work;
11850+ struct work_struct tx_work;
11851+
11852 unsigned long todo;
11853+ unsigned long flags;
11854+ unsigned short rx_needed_headroom;
11855 #define WORK_RX_MEMORY 0
11856-#define WORK_BRCM_NETCONSOLE_ON 1
11857-#define WORK_BRCM_NETCONSOLE_OFF 2
11858-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
11859-#define WORK_ALLOC_RX_SKB 4
11860-#endif
11861+
11862 bool zlp;
11863 u8 host_mac[ETH_ALEN];
11864-};
11865-
11866-#ifdef CONFIG_BRCM_NETCONSOLE
11867-
11868-static DEFINE_MUTEX(cleanup_netpoll_mutex);
11869-
11870-void cleanup_netpoll_lock(void)
11871-{
11872- mutex_lock(&cleanup_netpoll_mutex);
11873-}
11874
11875-void cleanup_netpoll_unlock(void)
11876-{
11877- if (mutex_is_locked(&cleanup_netpoll_mutex))
11878- mutex_unlock(&cleanup_netpoll_mutex);
11879-}
11880-#endif
11881-
11882-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
11883-#define MAX_RX_SKB_SIZE 2048
11884-#define UETH_RX_SKB_THRESHOLD 192
11885-#define UETH_RX_SKB_THRESH_NCM 48
11886-static struct sk_buff_head skb_rx_pool;
11887-static int rx_skb_q_no;
11888-static bool is_rx_prealloc_mode;
11889-static unsigned short max_skb_buf_sz, max_skb_buf_no;
11890+ /* stats */
11891+ unsigned long tx_throttle;
11892+ unsigned long rx_throttle;
11893+ unsigned int tx_aggr_cnt[DL_MAX_PKTS_PER_XFER];
11894+ unsigned int tx_pkts_rcvd;
11895+ unsigned int loop_brk_cnt;
11896+ struct dentry *uether_dent;
11897+ struct dentry *uether_dfile;
11898
11899-/**
11900- * static void prealloc_rx_skbs(void) - the function is to alloc skb
11901- * if pre-allocated memory was able to reach the max_skb_buf_no.
11902- *
11903- */
11904-static void alloc_rx_skb(void)
11905-{
11906- struct sk_buff *skb;
11907- unsigned long flags;
11908+ enum ifc_state state;
11909+ struct notifier_block cpufreq_notifier;
11910+ struct work_struct cpu_policy_w;
11911
11912- pr_debug("alloc_rx_skbs");
11913- spin_lock_irqsave(&skb_rx_pool.lock, flags);
11914- if (rx_skb_q_no < max_skb_buf_no) {
11915- skb = alloc_skb(max_skb_buf_sz, GFP_ATOMIC);
11916- if (!skb) {
11917- spin_unlock_irqrestore(&skb_rx_pool.lock, flags);
11918- return;
11919- } else {
11920- rx_skb_q_no++;
11921- pr_debug("TX_SKB NO:%d\n", skb_rx_pool.qlen);
11922- skb->signature = SKB_UETH_RX_THRESHOLD_SIG;
11923- __skb_queue_tail(&skb_rx_pool, skb);
11924- }
11925- }
11926- spin_unlock_irqrestore(&skb_rx_pool.lock, flags);
11927-}
11928-
11929-
11930-/**
11931- * static void refill_rx_skbs(struct sk_buff *skb) - put the skb buf back to queue to reuse
11932- *
11933- */
11934-static void refill_rx_skbs(struct sk_buff *skb)
11935-{
11936- unsigned long flags;
11937-
11938- spin_lock_irqsave(&skb_rx_pool.lock, flags);
11939- if (skb) {
11940- skb->signature = SKB_UETH_RX_THRESHOLD_SIG;
11941- __skb_queue_tail(&skb_rx_pool, skb);
11942- /* pr_info("@%d", skb_rx_pool.qlen); */
11943- } else {
11944- pr_warn("Can not refill the skb buffer....\n");
11945- }
11946- /* pr_info("@%d",skb_pool.qlen); */
11947- spin_unlock_irqrestore(&skb_rx_pool.lock, flags);
11948-}
11949-
11950-static void defer_kevent(struct eth_dev *dev, int flag);
11951-
11952-/**
11953- * void ueth_recycle_rx_skbs_data - recycle the skb buffer with
11954- * the new skb header.
11955- *
11956- */
11957-void ueth_recycle_rx_skb_data(unsigned char *skb_data, gfp_t gfp_flags, void *dev_handle)
11958-{
11959- struct sk_buff *skb;
11960- struct eth_dev *dev = dev_handle;
11961-
11962- skb = alloc_skb_uether_rx(max_skb_buf_sz, skb_data, gfp_flags);
11963- if (!skb) {
11964- pr_warn("retry: alloc ueth rx skb\n");
11965- dev->skb_data = skb_data;
11966- defer_kevent(dev, WORK_ALLOC_RX_SKB);
11967- } else
11968- refill_rx_skbs(skb);
11969-}
11970+ bool sg_enabled;
11971+};
11972
11973-/**
11974- * void ueth_rx_skb_queue_purge(struct sk_buff *skb) -
11975- * Delete all buffers on an &sk_buff list. Each buffer is removed from
11976- * the list and one reference dropped. This function takes the list
11977- * lock and is atomic with respect to other list locking functions.
11978- *
11979+/* when sg is enabled, sg_ctx is used to track skb each usb request will
11980+ * xfer
11981 */
11982-static void ueth_rx_skb_queue_purge(struct sk_buff_head *list)
11983-{
11984- struct sk_buff *skb;
11985- while ((skb = skb_dequeue(list)) != NULL) {
11986- skb->signature = 0;
11987- kfree_skb(skb);
11988- }
11989-}
11990+struct sg_ctx {
11991+ struct sk_buff_head skbs;
11992+};
11993
11994-/**
11995- * static void prealloc_rx_skbs(void) - reserve the skb bufs with
11996- * allocated memory for rx_submit.
11997- *
11998- */
11999-static void prealloc_rx_skbs(void)
12000-{
12001- struct sk_buff *skb;
12002- unsigned long flags;
12003
12004- pr_info("prealloc_rx_skbs");
12005- rx_skb_q_no = 0;
12006- is_rx_prealloc_mode = true;
12007-
12008- skb_queue_head_init(&skb_rx_pool);
12009- spin_lock_irqsave(&skb_rx_pool.lock, flags);
12010- while (skb_rx_pool.qlen < max_skb_buf_no) {
12011- skb = alloc_skb(max_skb_buf_sz, GFP_ATOMIC);
12012- if (!skb) {
12013- rx_skb_q_no = skb_rx_pool.qlen;
12014- spin_unlock_irqrestore(&skb_rx_pool.lock, flags);
12015- return;
12016- } else {
12017- rx_skb_q_no++;
12018- pr_debug("TX_SKB NO:%d\n", skb_rx_pool.qlen);
12019- skb->signature = SKB_UETH_RX_THRESHOLD_SIG;
12020- __skb_queue_tail(&skb_rx_pool, skb);
12021- }
12022- }
12023- spin_unlock_irqrestore(&skb_rx_pool.lock, flags);
12024-}
12025-#endif
12026+static void uether_debugfs_init(struct eth_dev *dev, const char *n);
12027+static void uether_debugfs_exit(struct eth_dev *dev);
12028
12029 /*-------------------------------------------------------------------------*/
12030
12031+
12032 #define RX_EXTRA 20 /* bytes guarding against rx overflows */
12033
12034 #define DEFAULT_QLEN 2 /* double buffering by default */
12035
12036-static unsigned qmult = 5;
12037+static unsigned qmult = 20;
12038 module_param(qmult, uint, S_IRUGO|S_IWUSR);
12039 MODULE_PARM_DESC(qmult, "queue length multiplier at high/super speed");
12040
12041+/*
12042+ * Usually downlink rates are higher than uplink rates and it
12043+ * deserve higher number of requests. For CAT-6 data rates of
12044+ * 300Mbps (~30 packets per milli-sec) 40 usb request may not
12045+ * be sufficient. At this rate and with interrupt moderation
12046+ * of interconnect, data can be very bursty. tx_qmult is the
12047+ * additional multipler on qmult.
12048+ */
12049+static unsigned tx_qmult = 1;
12050+module_param(tx_qmult, uint, S_IRUGO|S_IWUSR);
12051+MODULE_PARM_DESC(tx_qmult, "Additional queue length multiplier for tx");
12052+
12053 /* for dual-speed hardware, use deeper queues at high/super speed */
12054 static inline int qlen(struct usb_gadget *gadget)
12055 {
12056@@ -335,6 +186,11 @@ static inline int qlen(struct usb_gadget *gadget)
12057 }
12058
12059 /*-------------------------------------------------------------------------*/
12060+#define U_ETHER_RX_PENDING_TSHOLD 500
12061+
12062+static unsigned int u_ether_rx_pending_thld = U_ETHER_RX_PENDING_TSHOLD;
12063+module_param(u_ether_rx_pending_thld, uint, S_IRUGO | S_IWUSR);
12064+
12065
12066 /* REVISIT there must be a better way than having two sets
12067 * of debug calls ...
12068@@ -392,6 +248,25 @@ static int ueth_change_mtu(struct net_device *net, int new_mtu)
12069 return status;
12070 }
12071
12072+static int ueth_change_mtu_ip(struct net_device *net, int new_mtu)
12073+{
12074+ struct eth_dev *dev = netdev_priv(net);
12075+ unsigned long flags;
12076+ int status = 0;
12077+
12078+ spin_lock_irqsave(&dev->lock, flags);
12079+ if (new_mtu <= 0)
12080+ status = -EINVAL;
12081+ else
12082+ net->mtu = new_mtu;
12083+
12084+ DBG(dev, "[%s] MTU change: old=%d new=%d\n", net->name,
12085+ net->mtu, new_mtu);
12086+ spin_unlock_irqrestore(&dev->lock, flags);
12087+
12088+ return status;
12089+}
12090+
12091 static void eth_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *p)
12092 {
12093 struct eth_dev *dev = netdev_priv(net);
12094@@ -415,39 +290,8 @@ static const struct ethtool_ops ops = {
12095
12096 static void defer_kevent(struct eth_dev *dev, int flag)
12097 {
12098-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
12099- int testwkbit;
12100- unsigned long flags;
12101-
12102- spin_lock_irqsave(&dev->req_rx_lock, flags);
12103- testwkbit = test_and_set_bit(flag, &dev->todo);
12104- spin_unlock_irqrestore(&dev->req_rx_lock, flags);
12105-
12106- if (testwkbit)
12107- return;
12108-#else
12109 if (test_and_set_bit(flag, &dev->todo))
12110 return;
12111-#endif
12112-
12113-#ifdef CONFIG_BRCM_NETCONSOLE
12114- if ((flag == WORK_BRCM_NETCONSOLE_ON) || (flag == WORK_BRCM_NETCONSOLE_OFF)) {
12115- if (!queue_usbevent(&dev->usbevent_queue, flag)) {
12116- ERROR(dev, "event queue full, kevent %d may have been dropped\n", flag);
12117- return;
12118- }
12119- }
12120-#endif
12121-
12122-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
12123- if (dev->rx_workqueue) {
12124- if (!queue_work(dev->rx_workqueue, &dev->work))
12125- ERROR(dev, "kevent %d may have been dropped\n", flag);
12126- else
12127- DBG(dev, "kevent %d scheduled\n", flag);
12128- return;
12129- }
12130-#endif
12131 if (!schedule_work(&dev->work))
12132 ERROR(dev, "kevent %d may have been dropped\n", flag);
12133 else
12134@@ -455,6 +299,7 @@ static void defer_kevent(struct eth_dev *dev, int flag)
12135 }
12136
12137 static void rx_complete(struct usb_ep *ep, struct usb_request *req);
12138+static void tx_complete(struct usb_ep *ep, struct usb_request *req);
12139
12140 static int
12141 rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
12142@@ -464,16 +309,18 @@ rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
12143 size_t size = 0;
12144 struct usb_ep *out;
12145 unsigned long flags;
12146+ unsigned short reserve_headroom;
12147
12148 spin_lock_irqsave(&dev->lock, flags);
12149 if (dev->port_usb)
12150 out = dev->port_usb->out_ep;
12151 else
12152 out = NULL;
12153- spin_unlock_irqrestore(&dev->lock, flags);
12154
12155- if (!out)
12156+ if (!out) {
12157+ spin_unlock_irqrestore(&dev->lock, flags);
12158 return -ENOTCONN;
12159+ }
12160
12161
12162 /* Padding up to RX_EXTRA handles minor disagreements with host.
12163@@ -488,60 +335,42 @@ rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
12164 * means receivers can't recover lost synch on their own (because
12165 * new packets don't only start after a short RX).
12166 */
12167- size += sizeof(struct ethhdr) + dev->net->mtu + RX_EXTRA;
12168- size += dev->port_usb->header_len;
12169- size += out->maxpacket - 1;
12170- size -= size % out->maxpacket;
12171-
12172- if (dev->port_usb->is_fixed)
12173- size = max_t(size_t, size,
12174- dev->port_usb->fixed_out_len);
12175-
12176-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
12177- if (is_rx_prealloc_mode) {
12178- if (size > max_skb_buf_sz) {
12179- pr_info("skb data size = %d\n", size);
12180- skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags);
12181- } else
12182- skb = skb_dequeue(&skb_rx_pool);
12183-
12184- if (!skb) {
12185- alloc_rx_skb();
12186- pr_debug("No RX SKB...\n");
12187- goto enomem;
12188- }
12189- } else {
12190-#endif
12191- skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags);
12192- if (skb == NULL) {
12193- DBG(dev, "no rx skb\n");
12194- goto enomem;
12195- }
12196-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
12197+ size += sizeof(struct ethhdr) + dev->net->mtu + RX_EXTRA;
12198+ size += dev->port_usb->header_len;
12199+ size += out->maxpacket - 1;
12200+ size -= size % out->maxpacket;
12201+
12202+ if (dev->ul_max_pkts_per_xfer)
12203+ size *= dev->ul_max_pkts_per_xfer;
12204+
12205+ if (dev->port_usb->is_fixed)
12206+ size = max_t(size_t, size, dev->port_usb->fixed_out_len);
12207+ spin_unlock_irqrestore(&dev->lock, flags);
12208+
12209+ if (dev->rx_needed_headroom)
12210+ reserve_headroom = dev->rx_needed_headroom;
12211+ else
12212+ reserve_headroom = NET_IP_ALIGN;
12213+
12214+ pr_debug("%s: size: %zu + %d(hr)", __func__, size, reserve_headroom);
12215+
12216+ skb = alloc_skb(size + reserve_headroom, gfp_flags);
12217+ if (skb == NULL) {
12218+ DBG(dev, "no rx skb\n");
12219+ goto enomem;
12220 }
12221-#endif
12222
12223 /* Some platforms perform better when IP packets are aligned,
12224 * but on at least one, checksumming fails otherwise. Note:
12225 * RNDIS headers involve variable numbers of LE32 values.
12226 */
12227- skb_reserve(skb, NET_IP_ALIGN);
12228+ skb_reserve(skb, reserve_headroom);
12229
12230 req->buf = skb->data;
12231 req->length = size;
12232- req->complete = rx_complete;
12233 req->context = skb;
12234- req->dma = 0;
12235
12236-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
12237- /* Need lock since it could be prempted by rx_complete
12238- when rx_submit is executed from schedule queue. */
12239- spin_lock_irqsave(&dev->req_rx_lock, flags);
12240-#endif
12241 retval = usb_ep_queue(out, req, gfp_flags);
12242-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
12243- spin_unlock_irqrestore(&dev->req_rx_lock, flags);
12244-#endif
12245 if (retval == -ENOMEM)
12246 enomem:
12247 defer_kevent(dev, WORK_RX_MEMORY);
12248@@ -549,18 +378,16 @@ enomem:
12249 DBG(dev, "rx submit --> %d\n", retval);
12250 if (skb)
12251 dev_kfree_skb_any(skb);
12252- spin_lock_irqsave(&dev->req_lock, flags);
12253- list_add(&req->list, &dev->rx_reqs);
12254- spin_unlock_irqrestore(&dev->req_lock, flags);
12255 }
12256 return retval;
12257 }
12258
12259 static void rx_complete(struct usb_ep *ep, struct usb_request *req)
12260 {
12261- struct sk_buff *skb = req->context, *skb2;
12262+ struct sk_buff *skb = req->context;
12263 struct eth_dev *dev = ep->driver_data;
12264 int status = req->status;
12265+ bool queue = 0;
12266
12267 switch (status) {
12268
12269@@ -576,6 +403,10 @@ static void rx_complete(struct usb_ep *ep, struct usb_request *req)
12270 status = dev->unwrap(dev->port_usb,
12271 skb,
12272 &dev->rx_frames);
12273+ if (status == -EINVAL)
12274+ dev->net->stats.rx_errors++;
12275+ else if (status == -EOVERFLOW)
12276+ dev->net->stats.rx_over_errors++;
12277 } else {
12278 dev_kfree_skb_any(skb);
12279 status = -ENOTCONN;
12280@@ -584,30 +415,9 @@ static void rx_complete(struct usb_ep *ep, struct usb_request *req)
12281 } else {
12282 skb_queue_tail(&dev->rx_frames, skb);
12283 }
12284- skb = NULL;
12285-
12286- skb2 = skb_dequeue(&dev->rx_frames);
12287- while (skb2) {
12288- if (status < 0
12289- || ETH_HLEN > skb2->len
12290- || skb2->len > VLAN_ETH_FRAME_LEN) {
12291- dev->net->stats.rx_errors++;
12292- dev->net->stats.rx_length_errors++;
12293- DBG(dev, "rx length %d\n", skb2->len);
12294- dev_kfree_skb_any(skb2);
12295- goto next_frame;
12296- }
12297- skb2->protocol = eth_type_trans(skb2, dev->net);
12298- dev->net->stats.rx_packets++;
12299- dev->net->stats.rx_bytes += skb2->len;
12300
12301- /* no buffer copies needed, unless hardware can't
12302- * use skb buffers.
12303- */
12304- status = netif_rx(skb2);
12305-next_frame:
12306- skb2 = skb_dequeue(&dev->rx_frames);
12307- }
12308+ if (!status)
12309+ queue = 1;
12310 break;
12311
12312 /* software-driven interface shutdown */
12313@@ -630,29 +440,41 @@ quiesce:
12314 /* FALLTHROUGH */
12315
12316 default:
12317+ queue = 1;
12318+ dev_kfree_skb_any(skb);
12319 dev->net->stats.rx_errors++;
12320 DBG(dev, "rx status %d\n", status);
12321 break;
12322 }
12323
12324- if (skb)
12325- dev_kfree_skb_any(skb);
12326-
12327- if (!netif_running(dev->net)) {
12328 clean:
12329+ if (queue && dev->rx_frames.qlen <= u_ether_rx_pending_thld) {
12330+ if (rx_submit(dev, req, GFP_ATOMIC) < 0) {
12331+ spin_lock(&dev->req_lock);
12332+ list_add(&req->list, &dev->rx_reqs);
12333+ spin_unlock(&dev->req_lock);
12334+ }
12335+ } else {
12336+ /* rx buffers draining is delayed,defer further queuing to wq */
12337+ if (queue)
12338+ dev->rx_throttle++;
12339 spin_lock(&dev->req_lock);
12340 list_add(&req->list, &dev->rx_reqs);
12341 spin_unlock(&dev->req_lock);
12342- req = NULL;
12343 }
12344- if (req)
12345- rx_submit(dev, req, GFP_ATOMIC);
12346+
12347+ if (queue)
12348+ queue_work_on(0, uether_wq, &dev->rx_work);
12349 }
12350
12351-static int prealloc(struct list_head *list, struct usb_ep *ep, unsigned n)
12352+static int prealloc(struct list_head *list,
12353+ struct usb_ep *ep, unsigned n,
12354+ bool sg_supported, int hlen)
12355 {
12356 unsigned i;
12357 struct usb_request *req;
12358+ bool usb_in;
12359+ struct sg_ctx *sg_ctx;
12360
12361 if (!n)
12362 return -ENOMEM;
12363@@ -663,10 +485,37 @@ static int prealloc(struct list_head *list, struct usb_ep *ep, unsigned n)
12364 if (i-- == 0)
12365 goto extra;
12366 }
12367+
12368+ if (ep->desc->bEndpointAddress & USB_DIR_IN)
12369+ usb_in = true;
12370+ else
12371+ usb_in = false;
12372+
12373 while (i--) {
12374 req = usb_ep_alloc_request(ep, GFP_ATOMIC);
12375 if (!req)
12376 return list_empty(list) ? -ENOMEM : 0;
12377+ /* update completion handler */
12378+ if (usb_in) {
12379+ req->complete = tx_complete;
12380+ if (!sg_supported)
12381+ goto add_list;
12382+ req->sg = kmalloc(
12383+ DL_MAX_PKTS_PER_XFER *
12384+ sizeof(struct scatterlist),
12385+ GFP_ATOMIC);
12386+ if (!req->sg)
12387+ goto extra;
12388+ sg_ctx = kmalloc(sizeof(*sg_ctx), GFP_ATOMIC);
12389+ if (!sg_ctx)
12390+ goto extra;
12391+ req->context = sg_ctx;
12392+ req->buf = kzalloc(DL_MAX_PKTS_PER_XFER * hlen,
12393+ GFP_ATOMIC);
12394+ } else {
12395+ req->complete = rx_complete;
12396+ }
12397+add_list:
12398 list_add(&req->list, list);
12399 }
12400 return 0;
12401@@ -678,6 +527,13 @@ extra:
12402
12403 next = req->list.next;
12404 list_del(&req->list);
12405+
12406+ if (sg_supported) {
12407+ kfree(req->sg);
12408+ kfree(req->context);
12409+ kfree(req->buf);
12410+ }
12411+
12412 usb_ep_free_request(ep, req);
12413
12414 if (next == list)
12415@@ -693,10 +549,14 @@ static int alloc_requests(struct eth_dev *dev, struct gether *link, unsigned n)
12416 int status;
12417
12418 spin_lock(&dev->req_lock);
12419- status = prealloc(&dev->tx_reqs, link->in_ep, n);
12420+ status = prealloc(&dev->tx_reqs, link->in_ep, n * tx_qmult,
12421+ dev->sg_enabled,
12422+ dev->header_len);
12423 if (status < 0)
12424 goto fail;
12425- status = prealloc(&dev->rx_reqs, link->out_ep, n);
12426+ status = prealloc(&dev->rx_reqs, link->out_ep, n,
12427+ dev->sg_enabled,
12428+ dev->header_len);
12429 if (status < 0)
12430 goto fail;
12431 goto done;
12432@@ -711,16 +571,24 @@ static void rx_fill(struct eth_dev *dev, gfp_t gfp_flags)
12433 {
12434 struct usb_request *req;
12435 unsigned long flags;
12436+ int req_cnt = 0;
12437
12438 /* fill unused rxq slots with some skb */
12439 spin_lock_irqsave(&dev->req_lock, flags);
12440 while (!list_empty(&dev->rx_reqs)) {
12441+ /* break the nexus of continuous completion and re-submission*/
12442+ if (++req_cnt > qlen(dev->gadget))
12443+ break;
12444+
12445 req = container_of(dev->rx_reqs.next,
12446 struct usb_request, list);
12447 list_del_init(&req->list);
12448 spin_unlock_irqrestore(&dev->req_lock, flags);
12449
12450 if (rx_submit(dev, req, gfp_flags) < 0) {
12451+ spin_lock_irqsave(&dev->req_lock, flags);
12452+ list_add(&req->list, &dev->rx_reqs);
12453+ spin_unlock_irqrestore(&dev->req_lock, flags);
12454 defer_kevent(dev, WORK_RX_MEMORY);
12455 return;
12456 }
12457@@ -729,94 +597,105 @@ static void rx_fill(struct eth_dev *dev, gfp_t gfp_flags)
12458 }
12459 spin_unlock_irqrestore(&dev->req_lock, flags);
12460 }
12461-#ifdef CONFIG_BRCM_NETCONSOLE
12462-static void usb_test_work(struct work_struct *work)
12463+
12464+static __be16 ether_ip_type_trans(struct sk_buff *skb,
12465+ struct net_device *dev)
12466 {
12467- struct eth_dev *dev = container_of(work, struct eth_dev, work);
12468- uint32_t event;
12469-
12470- while (dequeue_usbevent(&dev->usbevent_queue, &event)) {
12471- switch (event) {
12472- case WORK_BRCM_NETCONSOLE_ON:
12473- cleanup_netpoll_lock();
12474- brcm_current_netcon_status(USB_RNDIS_ON);
12475- cleanup_netpoll_unlock();
12476- break;
12477+ __be16 protocol = 0;
12478
12479- case WORK_BRCM_NETCONSOLE_OFF:
12480- cleanup_netpoll_lock();
12481- brcm_current_netcon_status(USB_RNDIS_OFF);
12482- cleanup_netpoll_unlock();
12483- break;
12484+ skb->dev = dev;
12485
12486- default:
12487- break;
12488- }
12489+ switch (skb->data[0] & 0xf0) {
12490+ case 0x40:
12491+ protocol = htons(ETH_P_IP);
12492+ break;
12493+ case 0x60:
12494+ protocol = htons(ETH_P_IPV6);
12495+ break;
12496+ default:
12497+ if ((skb->data[0] & 0x40) == 0x00)
12498+ protocol = htons(ETH_P_MAP);
12499+ else
12500+ pr_debug_ratelimited("[%s] L3 protocol decode error: 0x%02x",
12501+ dev->name, skb->data[0] & 0xf0);
12502 }
12503- return;
12504+
12505+ return protocol;
12506 }
12507-#endif
12508
12509-static void eth_work(struct work_struct *work)
12510+static void process_rx_w(struct work_struct *work)
12511 {
12512- struct eth_dev *dev = container_of(work, struct eth_dev, work);
12513+ struct eth_dev *dev = container_of(work, struct eth_dev, rx_work);
12514+ struct sk_buff *skb;
12515+ int status = 0;
12516
12517-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
12518- int testwkbit;
12519- unsigned long flags;
12520+ if (!dev->port_usb)
12521+ return;
12522+
12523+ set_wake_up_idle(true);
12524+ while ((skb = skb_dequeue(&dev->rx_frames))) {
12525+ if (status < 0
12526+ || ETH_HLEN > skb->len
12527+ || (skb->len > ETH_FRAME_LEN &&
12528+ test_bit(RMNET_MODE_LLP_ETH, &dev->flags))) {
12529+ dev->net->stats.rx_errors++;
12530+ dev->net->stats.rx_length_errors++;
12531+ DBG(dev, "rx length %d\n", skb->len);
12532+ dev_kfree_skb_any(skb);
12533+ continue;
12534+ }
12535+ if (test_bit(RMNET_MODE_LLP_IP, &dev->flags))
12536+ skb->protocol = ether_ip_type_trans(skb, dev->net);
12537+ else
12538+ skb->protocol = eth_type_trans(skb, dev->net);
12539
12540- spin_lock_irqsave(&dev->req_rx_lock, flags);
12541- testwkbit = test_and_clear_bit(WORK_RX_MEMORY, &dev->todo);
12542- spin_unlock_irqrestore(&dev->req_rx_lock, flags);
12543+ dev->net->stats.rx_packets++;
12544+ dev->net->stats.rx_bytes += skb->len;
12545
12546- if (testwkbit) {
12547- if (netif_running(dev->net))
12548- rx_fill(dev, GFP_KERNEL);
12549- }
12550-#ifdef CONFIG_BRCM_NETCONSOLE
12551- else {
12552- usb_test_work(work);
12553+ status = netif_rx_ni(skb);
12554 }
12555+ set_wake_up_idle(false);
12556
12557- if (test_and_clear_bit(WORK_ALLOC_RX_SKB, &dev->todo))
12558- ueth_recycle_rx_skb_data(dev->skb_data, GFP_KERNEL, dev);
12559-#endif
12560-
12561- if (dev->todo)
12562- DBG(dev, "work done, flags = 0x%lx\n", dev->todo);
12563- return;
12564+ if (netif_running(dev->net))
12565+ rx_fill(dev, GFP_KERNEL);
12566+}
12567
12568-#else /* CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION */
12569+static void eth_work(struct work_struct *work)
12570+{
12571+ struct eth_dev *dev = container_of(work, struct eth_dev, work);
12572
12573 if (test_and_clear_bit(WORK_RX_MEMORY, &dev->todo)) {
12574 if (netif_running(dev->net))
12575 rx_fill(dev, GFP_KERNEL);
12576 }
12577-#ifdef CONFIG_BRCM_NETCONSOLE
12578- else {
12579- usb_test_work(work);
12580- }
12581-#endif
12582
12583 if (dev->todo)
12584 DBG(dev, "work done, flags = 0x%lx\n", dev->todo);
12585-
12586-#endif /* CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION */
12587-
12588-}
12589-
12590-
12591-#ifdef CONFIG_NET_POLL_CONTROLLER
12592-static void eth_poll_controller(struct net_device *dev)
12593-{
12594- return; /* do not thing.... */
12595 }
12596-#endif
12597
12598 static void tx_complete(struct usb_ep *ep, struct usb_request *req)
12599 {
12600- struct sk_buff *skb = req->context;
12601- struct eth_dev *dev = ep->driver_data;
12602+ struct sk_buff *skb;
12603+ struct eth_dev *dev;
12604+ struct net_device *net;
12605+ struct usb_request *new_req;
12606+ struct usb_ep *in;
12607+ int n = 1;
12608+ int length;
12609+ int retval;
12610+
12611+ if (!ep->driver_data) {
12612+ usb_ep_free_request(ep, req);
12613+ return;
12614+ }
12615+
12616+ dev = ep->driver_data;
12617+ net = dev->net;
12618+
12619+ if (!dev->port_usb) {
12620+ usb_ep_free_request(ep, req);
12621+ return;
12622+ }
12623
12624 switch (req->status) {
12625 default:
12626@@ -827,23 +706,301 @@ static void tx_complete(struct usb_ep *ep, struct usb_request *req)
12627 case -ESHUTDOWN: /* disconnect etc */
12628 break;
12629 case 0:
12630- dev->net->stats.tx_bytes += skb->len;
12631+ if (!req->zero)
12632+ dev->net->stats.tx_bytes += req->actual-1;
12633+ else
12634+ dev->net->stats.tx_bytes += req->actual;
12635+ }
12636+
12637+ if (req->num_sgs) {
12638+ struct sg_ctx *sg_ctx = req->context;
12639+
12640+ n = skb_queue_len(&sg_ctx->skbs);
12641+ dev->tx_aggr_cnt[n-1]++;
12642+
12643+ /* sg_ctx is only accessible here, can use lock-free version */
12644+ __skb_queue_purge(&sg_ctx->skbs);
12645+ }
12646+
12647+ dev->net->stats.tx_packets += n;
12648+
12649+ spin_lock(&dev->req_lock);
12650+ list_add_tail(&req->list, &dev->tx_reqs);
12651+
12652+ if (req->num_sgs) {
12653+ if (!req->status)
12654+ queue_work(uether_tx_wq, &dev->tx_work);
12655+
12656+ spin_unlock(&dev->req_lock);
12657+ return;
12658 }
12659- dev->net->stats.tx_packets++;
12660
12661- spin_lock(&dev->req_lock);
12662- list_add(&req->list, &dev->tx_reqs);
12663- spin_unlock(&dev->req_lock);
12664- dev_kfree_skb_any(skb);
12665+ if (dev->port_usb->multi_pkt_xfer && !req->context) {
12666+ dev->no_tx_req_used--;
12667+ req->length = 0;
12668+ in = dev->port_usb->in_ep;
12669+
12670+ if (!list_empty(&dev->tx_reqs)) {
12671+ new_req = container_of(dev->tx_reqs.next,
12672+ struct usb_request, list);
12673+ list_del(&new_req->list);
12674+ spin_unlock(&dev->req_lock);
12675+ if (new_req->length > 0) {
12676+ length = new_req->length;
12677+
12678+ /* NCM requires no zlp if transfer is
12679+ * dwNtbInMaxSize */
12680+ if (dev->port_usb->is_fixed &&
12681+ length == dev->port_usb->fixed_in_len &&
12682+ (length % in->maxpacket) == 0)
12683+ new_req->zero = 0;
12684+ else
12685+ new_req->zero = 1;
12686+
12687+ /* use zlp framing on tx for strict CDC-Ether
12688+ * conformance, though any robust network rx
12689+ * path ignores extra padding. and some hardware
12690+ * doesn't like to write zlps.
12691+ */
12692+ if (new_req->zero && !dev->zlp &&
12693+ (length % in->maxpacket) == 0) {
12694+ new_req->zero = 0;
12695+ length++;
12696+ }
12697+
12698+ new_req->length = length;
12699+ retval = usb_ep_queue(in, new_req, GFP_ATOMIC);
12700+ switch (retval) {
12701+ default:
12702+ DBG(dev, "tx queue err %d\n", retval);
12703+ new_req->length = 0;
12704+ spin_lock(&dev->req_lock);
12705+ list_add_tail(&new_req->list,
12706+ &dev->tx_reqs);
12707+ spin_unlock(&dev->req_lock);
12708+ break;
12709+ case 0:
12710+ spin_lock(&dev->req_lock);
12711+ dev->no_tx_req_used++;
12712+ spin_unlock(&dev->req_lock);
12713+ net->trans_start = jiffies;
12714+ }
12715+ } else {
12716+ spin_lock(&dev->req_lock);
12717+ /*
12718+ * Put the idle request at the back of the
12719+ * queue. The xmit function will put the
12720+ * unfinished request at the beginning of the
12721+ * queue.
12722+ */
12723+ list_add_tail(&new_req->list, &dev->tx_reqs);
12724+ spin_unlock(&dev->req_lock);
12725+ }
12726+ } else {
12727+ spin_unlock(&dev->req_lock);
12728+ }
12729+ } else {
12730+ skb = req->context;
12731+ /* Is aggregation already enabled and buffers allocated ? */
12732+ if (dev->port_usb->multi_pkt_xfer && dev->tx_req_bufsize) {
12733+ req->buf = kzalloc(dev->tx_req_bufsize, GFP_ATOMIC);
12734+ req->context = NULL;
12735+ } else {
12736+ req->buf = NULL;
12737+ }
12738+
12739+ spin_unlock(&dev->req_lock);
12740+ dev_kfree_skb_any(skb);
12741+ }
12742+
12743+ if (netif_carrier_ok(dev->net))
12744+ netif_wake_queue(dev->net);
12745+}
12746+
12747+static inline int is_promisc(u16 cdc_filter)
12748+{
12749+ return cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
12750+}
12751+
12752+static int alloc_tx_buffer(struct eth_dev *dev)
12753+{
12754+ struct list_head *act;
12755+ struct usb_request *req;
12756+
12757+ dev->tx_req_bufsize = (dev->dl_max_pkts_per_xfer *
12758+ (dev->net->mtu
12759+ + sizeof(struct ethhdr)
12760+ /* size of rndis_packet_msg_type */
12761+ + 44
12762+ + 22));
12763+
12764+ list_for_each(act, &dev->tx_reqs) {
12765+ req = container_of(act, struct usb_request, list);
12766+ if (!req->buf) {
12767+ req->buf = kzalloc(dev->tx_req_bufsize,
12768+ GFP_ATOMIC);
12769+ if (!req->buf)
12770+ goto free_buf;
12771+ }
12772+ /* req->context is not used for multi_pkt_xfers */
12773+ req->context = NULL;
12774+ }
12775+ return 0;
12776+
12777+free_buf:
12778+ /* tx_req_bufsize = 0 retries mem alloc on next eth_start_xmit */
12779+ dev->tx_req_bufsize = 0;
12780+ list_for_each(act, &dev->tx_reqs) {
12781+ req = container_of(act, struct usb_request, list);
12782+ kfree(req->buf);
12783+ req->buf = NULL;
12784+ }
12785+ return -ENOMEM;
12786+}
12787+
12788+static void process_tx_w(struct work_struct *w)
12789+{
12790+ struct eth_dev *dev = container_of(w, struct eth_dev, tx_work);
12791+ struct net_device *net = NULL;
12792+ struct sk_buff *skb = NULL;
12793+ struct sg_ctx *sg_ctx;
12794+ struct usb_request *req;
12795+ struct usb_ep *in = NULL;
12796+ int ret, count, hlen = 0, hdr_offset;
12797+ uint32_t max_size = 0;
12798+ uint32_t max_num_pkts = 1;
12799+ unsigned long flags;
12800+ bool header_on = false;
12801+ int req_cnt = 0;
12802+ bool port_usb_active;
12803+
12804+ spin_lock_irqsave(&dev->lock, flags);
12805+ if (dev->port_usb) {
12806+ in = dev->port_usb->in_ep;
12807+ max_size = dev->dl_max_xfer_size;
12808+ max_num_pkts = dev->dl_max_pkts_per_xfer;
12809+ if (!max_num_pkts)
12810+ max_num_pkts = 1;
12811+ hlen = dev->header_len;
12812+ net = dev->net;
12813+ }
12814+ spin_unlock_irqrestore(&dev->lock, flags);
12815+
12816+ spin_lock_irqsave(&dev->req_lock, flags);
12817+ while (in && !list_empty(&dev->tx_reqs) &&
12818+ (skb = skb_dequeue(&dev->tx_skb_q))) {
12819+ req = list_first_entry(&dev->tx_reqs, struct usb_request,
12820+ list);
12821+ list_del(&req->list);
12822+ spin_unlock_irqrestore(&dev->req_lock, flags);
12823+
12824+ req->num_sgs = 0;
12825+ req->zero = 1;
12826+ req->length = 0;
12827+ sg_ctx = req->context;
12828+ skb_queue_head_init(&sg_ctx->skbs);
12829+ sg_init_table(req->sg, DL_MAX_PKTS_PER_XFER);
12830+
12831+ hdr_offset = 0;
12832+ count = 1;
12833+ do {
12834+ /* spinlock can be avoided if buffer can passed
12835+ * wrap callback argument. However, it requires
12836+ * changes to all existing clients
12837+ */
12838+ spin_lock_irqsave(&dev->lock, flags);
12839+ if (!dev->port_usb) {
12840+ spin_unlock_irqrestore(&dev->lock, flags);
12841+ skb_queue_purge(&sg_ctx->skbs);
12842+ kfree(req->sg);
12843+ kfree(req->context);
12844+ kfree(req->buf);
12845+ usb_ep_free_request(in, req);
12846+
12847+ return;
12848+ }
12849+
12850+ if (hlen && dev->wrap) {
12851+ dev->port_usb->header = req->buf + hdr_offset;
12852+ skb = dev->wrap(dev->port_usb, skb);
12853+ header_on = true;
12854+ }
12855+ spin_unlock_irqrestore(&dev->lock, flags);
12856+
12857+ if (header_on) {
12858+ sg_set_buf(&req->sg[req->num_sgs],
12859+ req->buf + hdr_offset, hlen);
12860+ req->num_sgs++;
12861+ hdr_offset += hlen;
12862+ req->length += hlen;
12863+ }
12864+
12865+ /* skb processing */
12866+ sg_set_buf(&req->sg[req->num_sgs], skb->data, skb->len);
12867+ req->num_sgs++;
12868+
12869+ req->length += skb->len;
12870+ skb_queue_tail(&sg_ctx->skbs, skb);
12871+
12872+ skb = skb_dequeue(&dev->tx_skb_q);
12873+ if (!skb)
12874+ break;
12875+ if ((req->length + skb->len + hlen) >= max_size ||
12876+ count >= max_num_pkts) {
12877+ skb_queue_head(&dev->tx_skb_q, skb);
12878+ break;
12879+ }
12880+ count++;
12881+ } while (true);
12882+
12883+ sg_mark_end(&req->sg[req->num_sgs - 1]);
12884+
12885+ spin_lock_irqsave(&dev->lock, flags);
12886+ if (dev->port_usb) {
12887+ in = dev->port_usb->in_ep;
12888+ port_usb_active = 1;
12889+ } else {
12890+ port_usb_active = 0;
12891+ }
12892+ spin_unlock_irqrestore(&dev->lock, flags);
12893+
12894+ if (!port_usb_active) {
12895+ __skb_queue_purge(&sg_ctx->skbs);
12896+ kfree(req->sg);
12897+ kfree(req->context);
12898+ kfree(req->buf);
12899+ usb_ep_free_request(in, req);
12900+
12901+ return;
12902+ }
12903+
12904+ ret = usb_ep_queue(in, req, GFP_KERNEL);
12905+ spin_lock_irqsave(&dev->req_lock, flags);
12906+ switch (ret) {
12907+ default:
12908+ dev->net->stats.tx_dropped +=
12909+ skb_queue_len(&sg_ctx->skbs);
12910+
12911+ __skb_queue_purge(&sg_ctx->skbs);
12912+ list_add_tail(&req->list, &dev->tx_reqs);
12913+ break;
12914+ case 0:
12915+ net->trans_start = jiffies;
12916+ }
12917+
12918+ /* break the loop after processing 10 packets
12919+ * otherwise wd may kick in
12920+ */
12921+ if (ret || ++req_cnt > 10) {
12922+ dev->loop_brk_cnt++;
12923+ break;
12924+ }
12925
12926- atomic_dec(&dev->tx_qlen);
12927- if (netif_carrier_ok(dev->net))
12928- netif_wake_queue(dev->net);
12929-}
12930+ if (dev->tx_skb_q.qlen < tx_start_threshold)
12931+ netif_start_queue(net);
12932
12933-static inline int is_promisc(u16 cdc_filter)
12934-{
12935- return cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
12936+ }
12937+ spin_unlock_irqrestore(&dev->req_lock, flags);
12938 }
12939
12940 static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
12941@@ -854,16 +1011,15 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
12942 int retval;
12943 struct usb_request *req = NULL;
12944 unsigned long flags;
12945- struct usb_ep *in;
12946- u16 cdc_filter;
12947+ struct usb_ep *in = NULL;
12948+ u16 cdc_filter = 0;
12949+ bool multi_pkt_xfer = false;
12950
12951 spin_lock_irqsave(&dev->lock, flags);
12952 if (dev->port_usb) {
12953 in = dev->port_usb->in_ep;
12954 cdc_filter = dev->port_usb->cdc_filter;
12955- } else {
12956- in = NULL;
12957- cdc_filter = 0;
12958+ multi_pkt_xfer = dev->port_usb->multi_pkt_xfer;
12959 }
12960 spin_unlock_irqrestore(&dev->lock, flags);
12961
12962@@ -872,8 +1028,9 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
12963 return NETDEV_TX_OK;
12964 }
12965
12966- /* apply outgoing CDC or RNDIS filters */
12967- if (!is_promisc(cdc_filter)) {
12968+ /* apply outgoing CDC or RNDIS filters only for ETH packets */
12969+ if (!test_bit(RMNET_MODE_LLP_IP, &dev->flags) &&
12970+ !is_promisc(cdc_filter)) {
12971 u8 *dest = skb->data;
12972
12973 if (is_multicast_ether_addr(dest)) {
12974@@ -894,7 +1051,45 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
12975 /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
12976 }
12977
12978+ dev->tx_pkts_rcvd++;
12979+ if (dev->sg_enabled) {
12980+ skb_queue_tail(&dev->tx_skb_q, skb);
12981+ if (dev->tx_skb_q.qlen > tx_stop_threshold) {
12982+ dev->tx_throttle++;
12983+ netif_stop_queue(net);
12984+ }
12985+
12986+ queue_work(uether_tx_wq, &dev->tx_work);
12987+ return NETDEV_TX_OK;
12988+ }
12989+
12990+ /*
12991+ * No buffer copies needed, unless the network stack did it
12992+ * or the hardware can't use skb buffers or there's not enough
12993+ * enough space for extra headers we need.
12994+ */
12995+ spin_lock_irqsave(&dev->lock, flags);
12996+ if (dev->wrap && dev->port_usb)
12997+ skb = dev->wrap(dev->port_usb, skb);
12998+ spin_unlock_irqrestore(&dev->lock, flags);
12999+
13000+ if (!skb) {
13001+ dev->net->stats.tx_dropped++;
13002+
13003+ /* no error code for dropped packets */
13004+ return NETDEV_TX_OK;
13005+ }
13006+
13007+ /* Allocate memory for tx_reqs to support multi packet transfer */
13008 spin_lock_irqsave(&dev->req_lock, flags);
13009+ if (multi_pkt_xfer && !dev->tx_req_bufsize) {
13010+ retval = alloc_tx_buffer(dev);
13011+ if (retval < 0) {
13012+ spin_unlock_irqrestore(&dev->req_lock, flags);
13013+ return -ENOMEM;
13014+ }
13015+ }
13016+
13017 /*
13018 * this freelist can be empty if an interrupt triggered disconnect()
13019 * and reconfigured the gadget (shutting down this queue) after the
13020@@ -909,46 +1104,54 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
13021 list_del(&req->list);
13022
13023 /* temporarily stop TX queue when the freelist empties */
13024- if (list_empty(&dev->tx_reqs))
13025+ if (list_empty(&dev->tx_reqs)) {
13026+ /*
13027+ * tx_throttle gives info about number of times u_ether
13028+ * asked network layer to stop queueing packets to it
13029+ * when transmit resources are unavailable
13030+ */
13031+ dev->tx_throttle++;
13032 netif_stop_queue(net);
13033+ }
13034 spin_unlock_irqrestore(&dev->req_lock, flags);
13035
13036- /* no buffer copies needed, unless the network stack did it
13037- * or the hardware can't use skb buffers.
13038- * or there's not enough space for extra headers we need
13039- */
13040- if (skb->signature != SKB_NETPOLL_SIGNATURE) {
13041- if (dev->wrap) {
13042- unsigned long flags;
13043
13044- spin_lock_irqsave(&dev->lock, flags);
13045- if (dev->port_usb)
13046- skb = dev->wrap(dev->port_usb, skb);
13047- spin_unlock_irqrestore(&dev->lock, flags);
13048- if (!skb)
13049- goto drop;
13050-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
13051- /* The following is to eliminate to malloc for
13052- the unaligned memory*/
13053- spin_lock_irqsave(&dev->lock, flags);
13054- if (skb_headroom(skb) >
13055- ((unsigned long)skb->data & 3)) {
13056- u8 *data = skb->data;
13057- size_t len = skb_headlen(skb);
13058- skb->data -= ((unsigned long)skb->data & 3);
13059- memmove(skb->data, data, len);
13060- skb_set_tail_pointer(skb, len);
13061- pr_debug("mem_mv");
13062+ if (multi_pkt_xfer) {
13063+
13064+ pr_debug("req->length:%d header_len:%u\n"
13065+ "skb->len:%d skb->data_len:%d\n",
13066+ req->length, dev->header_len,
13067+ skb->len, skb->data_len);
13068+ /* Add RNDIS Header */
13069+ memcpy(req->buf + req->length, dev->port_usb->header,
13070+ dev->header_len);
13071+ /* Increment req length by header size */
13072+ req->length += dev->header_len;
13073+ /* Copy received IP data from SKB */
13074+ memcpy(req->buf + req->length, skb->data, skb->len);
13075+ /* Increment req length by skb data length */
13076+ req->length += skb->len;
13077+ length = req->length;
13078+ dev_kfree_skb_any(skb);
13079+
13080+ spin_lock_irqsave(&dev->req_lock, flags);
13081+ dev->tx_skb_hold_count++;
13082+ if (dev->tx_skb_hold_count < dev->dl_max_pkts_per_xfer) {
13083+ if (dev->no_tx_req_used > TX_REQ_THRESHOLD) {
13084+ list_add(&req->list, &dev->tx_reqs);
13085+ spin_unlock_irqrestore(&dev->req_lock, flags);
13086+ goto success;
13087 }
13088- spin_unlock_irqrestore(&dev->lock, flags);
13089-#endif
13090 }
13091- }
13092- length = skb->len;
13093
13094- req->buf = skb->data;
13095- req->context = skb;
13096- req->complete = tx_complete;
13097+ dev->no_tx_req_used++;
13098+ dev->tx_skb_hold_count = 0;
13099+ spin_unlock_irqrestore(&dev->req_lock, flags);
13100+ } else {
13101+ length = skb->len;
13102+ req->buf = skb->data;
13103+ req->context = skb;
13104+ }
13105
13106 /* NCM requires no zlp if transfer is dwNtbInMaxSize */
13107 if (dev->port_usb->is_fixed &&
13108@@ -962,46 +1165,50 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
13109 * though any robust network rx path ignores extra padding.
13110 * and some hardware doesn't like to write zlps.
13111 */
13112- if (req->zero && !dev->zlp && (length % in->maxpacket) == 0)
13113+ if (req->zero && !dev->zlp && (length % in->maxpacket) == 0) {
13114+ req->zero = 0;
13115 length++;
13116+ }
13117
13118 req->length = length;
13119
13120 /* throttle high/super speed IRQ rate back slightly */
13121- if (gadget_is_dualspeed(dev->gadget))
13122- req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH ||
13123- dev->gadget->speed == USB_SPEED_SUPER)
13124- ? ((atomic_read(&dev->tx_qlen) % qmult) != 0)
13125- : 0;
13126-
13127- req->dma = 0;
13128+ if (gadget_is_dualspeed(dev->gadget) &&
13129+ (dev->gadget->speed == USB_SPEED_HIGH ||
13130+ dev->gadget->speed == USB_SPEED_SUPER)) {
13131+ dev->tx_qlen++;
13132+ if (dev->tx_qlen == (qmult/2)) {
13133+ req->no_interrupt = 0;
13134+ dev->tx_qlen = 0;
13135+ } else {
13136+ req->no_interrupt = 1;
13137+ }
13138+ } else {
13139+ req->no_interrupt = 0;
13140+ }
13141
13142-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
13143- spin_lock_irqsave(&dev->req_lock, flags);
13144-#endif
13145 retval = usb_ep_queue(in, req, GFP_ATOMIC);
13146-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
13147- spin_unlock_irqrestore(&dev->req_lock, flags);
13148-#endif
13149 switch (retval) {
13150 default:
13151 DBG(dev, "tx queue err %d\n", retval);
13152 break;
13153 case 0:
13154 net->trans_start = jiffies;
13155- atomic_inc(&dev->tx_qlen);
13156 }
13157
13158 if (retval) {
13159- dev_kfree_skb_any(skb);
13160-drop:
13161+ if (!multi_pkt_xfer)
13162+ dev_kfree_skb_any(skb);
13163+ else
13164+ req->length = 0;
13165 dev->net->stats.tx_dropped++;
13166 spin_lock_irqsave(&dev->req_lock, flags);
13167 if (list_empty(&dev->tx_reqs))
13168 netif_start_queue(net);
13169- list_add(&req->list, &dev->tx_reqs);
13170+ list_add_tail(&req->list, &dev->tx_reqs);
13171 spin_unlock_irqrestore(&dev->req_lock, flags);
13172 }
13173+success:
13174 return NETDEV_TX_OK;
13175 }
13176
13177@@ -1015,25 +1222,34 @@ static void eth_start(struct eth_dev *dev, gfp_t gfp_flags)
13178 rx_fill(dev, gfp_flags);
13179
13180 /* and open the tx floodgates */
13181- atomic_set(&dev->tx_qlen, 0);
13182+ dev->tx_qlen = 0;
13183 netif_wake_queue(dev->net);
13184-
13185-#ifdef CONFIG_BRCM_NETCONSOLE
13186- defer_kevent(dev, WORK_BRCM_NETCONSOLE_ON);
13187-#endif
13188 }
13189
13190 static int eth_open(struct net_device *net)
13191 {
13192 struct eth_dev *dev = netdev_priv(net);
13193 struct gether *link;
13194+ bool wait_for_rx_trigger;
13195+ int i;
13196
13197 DBG(dev, "%s\n", __func__);
13198- if (netif_carrier_ok(dev->net))
13199- eth_start(dev, GFP_KERNEL);
13200
13201 spin_lock_irq(&dev->lock);
13202 link = dev->port_usb;
13203+ spin_unlock_irq(&dev->lock);
13204+
13205+ wait_for_rx_trigger = dev->rx_trigger_enabled && link &&
13206+ !link->rx_triggered;
13207+
13208+ if (netif_carrier_ok(dev->net) && !wait_for_rx_trigger)
13209+ eth_start(dev, GFP_KERNEL);
13210+
13211+ dev->state = ETH_START;
13212+ for_each_online_cpu(i)
13213+ cpufreq_update_policy(i);
13214+
13215+ spin_lock_irq(&dev->lock);
13216 if (link && link->open)
13217 link->open(link);
13218 spin_unlock_irq(&dev->lock);
13219@@ -1045,8 +1261,11 @@ static int eth_stop(struct net_device *net)
13220 {
13221 struct eth_dev *dev = netdev_priv(net);
13222 unsigned long flags;
13223+ int i;
13224+ enum ifc_state prev_state;
13225
13226 VDBG(dev, "%s\n", __func__);
13227+
13228 netif_stop_queue(net);
13229
13230 DBG(dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
13231@@ -1078,6 +1297,14 @@ static int eth_stop(struct net_device *net)
13232 usb_ep_disable(link->in_ep);
13233 usb_ep_disable(link->out_ep);
13234 if (netif_carrier_ok(net)) {
13235+ if (config_ep_by_speed(dev->gadget, &link->func,
13236+ link->in_ep) ||
13237+ config_ep_by_speed(dev->gadget, &link->func,
13238+ link->out_ep)) {
13239+ link->in_ep->desc = NULL;
13240+ link->out_ep->desc = NULL;
13241+ return -EINVAL;
13242+ }
13243 DBG(dev, "host still using in/out endpoints\n");
13244 link->in_ep->desc = in;
13245 link->out_ep->desc = out;
13246@@ -1087,6 +1314,14 @@ static int eth_stop(struct net_device *net)
13247 }
13248 spin_unlock_irqrestore(&dev->lock, flags);
13249
13250+ prev_state = dev->state;
13251+ dev->state = ETH_STOP;
13252+
13253+ /* if previous state is eth_start, update cpufreq policy to normal */
13254+ if (prev_state == ETH_START)
13255+ for_each_online_cpu(i)
13256+ cpufreq_update_policy(i);
13257+
13258 return 0;
13259 }
13260
13261@@ -1102,7 +1337,6 @@ static char *host_addr;
13262 module_param(host_addr, charp, S_IRUGO);
13263 MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
13264
13265-#if 0 /* See gether_setup */
13266 static int get_ether_addr(const char *str, u8 *dev_addr)
13267 {
13268 if (str) {
13269@@ -1115,7 +1349,7 @@ static int get_ether_addr(const char *str, u8 *dev_addr)
13270 str++;
13271 num = hex_to_bin(*str++) << 4;
13272 num |= hex_to_bin(*str++);
13273- dev_addr[i] = num;
13274+ dev_addr [i] = num;
13275 }
13276 if (is_valid_ether_addr(dev_addr))
13277 return 0;
13278@@ -1123,24 +1357,214 @@ static int get_ether_addr(const char *str, u8 *dev_addr)
13279 eth_random_addr(dev_addr);
13280 return 1;
13281 }
13282-#endif
13283+
13284+static int ether_ioctl(struct net_device *, struct ifreq *, int);
13285
13286 static const struct net_device_ops eth_netdev_ops = {
13287 .ndo_open = eth_open,
13288 .ndo_stop = eth_stop,
13289 .ndo_start_xmit = eth_start_xmit,
13290+ .ndo_do_ioctl = ether_ioctl,
13291 .ndo_change_mtu = ueth_change_mtu,
13292- .ndo_set_mac_address = eth_mac_addr,
13293+ .ndo_set_mac_address = eth_mac_addr,
13294 .ndo_validate_addr = eth_validate_addr,
13295-#ifdef CONFIG_NET_POLL_CONTROLLER
13296- .ndo_poll_controller = eth_poll_controller,
13297-#endif
13298 };
13299
13300+static const struct net_device_ops eth_netdev_ops_ip = {
13301+ .ndo_open = eth_open,
13302+ .ndo_stop = eth_stop,
13303+ .ndo_start_xmit = eth_start_xmit,
13304+ .ndo_do_ioctl = ether_ioctl,
13305+ .ndo_change_mtu = ueth_change_mtu_ip,
13306+ .ndo_set_mac_address = 0,
13307+ .ndo_validate_addr = 0,
13308+};
13309+
13310+static int rmnet_ioctl_extended(struct net_device *dev, struct ifreq *ifr)
13311+{
13312+ struct rmnet_ioctl_extended_s ext_cmd;
13313+ struct eth_dev *eth_dev = netdev_priv(dev);
13314+ int rc = 0;
13315+
13316+ rc = copy_from_user(&ext_cmd, ifr->ifr_ifru.ifru_data,
13317+ sizeof(struct rmnet_ioctl_extended_s));
13318+
13319+ if (rc) {
13320+ DBG("%s(): copy_from_user() failed\n", __func__);
13321+ return rc;
13322+ }
13323+
13324+ switch (ext_cmd.extended_ioctl) {
13325+ case RMNET_IOCTL_GET_SUPPORTED_FEATURES:
13326+ ext_cmd.u.data = 0;
13327+ break;
13328+
13329+ case RMNET_IOCTL_SET_MRU:
13330+ if (netif_running(dev))
13331+ return -EBUSY;
13332+
13333+ /* 16K max */
13334+ if ((size_t)ext_cmd.u.data > 0x4000)
13335+ return -EINVAL;
13336+
13337+ if (eth_dev->port_usb) {
13338+ eth_dev->port_usb->is_fixed = true;
13339+ eth_dev->port_usb->fixed_out_len =
13340+ (size_t) ext_cmd.u.data;
13341+ DBG("[%s] rmnet_ioctl(): SET MRU to %u\n", dev->name,
13342+ eth_dev->mru);
13343+ } else {
13344+ pr_err("[%s]: %s: SET MRU failed. Cable disconnected\n",
13345+ dev->name, __func__);
13346+ return -ENODEV;
13347+ }
13348+ break;
13349+
13350+ case RMNET_IOCTL_GET_MRU:
13351+ if (eth_dev->port_usb) {
13352+ ext_cmd.u.data = eth_dev->port_usb->is_fixed ?
13353+ eth_dev->port_usb->fixed_out_len :
13354+ dev->mtu;
13355+ } else {
13356+ pr_err("[%s]: %s: GET MRU failed. Cable disconnected\n",
13357+ dev->name, __func__);
13358+ return -ENODEV;
13359+ }
13360+ break;
13361+
13362+ case RMNET_IOCTL_GET_DRIVER_NAME:
13363+ strlcpy(ext_cmd.u.if_name, dev->name,
13364+ sizeof(ext_cmd.u.if_name));
13365+ break;
13366+
13367+ default:
13368+ break;
13369+ }
13370+
13371+ rc = copy_to_user(ifr->ifr_ifru.ifru_data, &ext_cmd,
13372+ sizeof(struct rmnet_ioctl_extended_s));
13373+
13374+ if (rc)
13375+ DBG("%s(): copy_to_user() failed\n", __func__);
13376+ return rc;
13377+}
13378+
13379+static int ether_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
13380+{
13381+ struct eth_dev *eth_dev = netdev_priv(dev);
13382+ void __user *addr = (void __user *) ifr->ifr_ifru.ifru_data;
13383+ int prev_mtu = dev->mtu;
13384+ u32 state, old_opmode;
13385+ int rc = -EFAULT;
13386+
13387+ old_opmode = eth_dev->flags;
13388+ /* Process IOCTL command */
13389+ switch (cmd) {
13390+ case RMNET_IOCTL_SET_LLP_ETHERNET: /*Set Ethernet protocol*/
13391+ /* Perform Ethernet config only if in IP mode currently*/
13392+ if (test_bit(RMNET_MODE_LLP_IP, ð_dev->flags)) {
13393+ ether_setup(dev);
13394+ dev->mtu = prev_mtu;
13395+ dev->netdev_ops = ð_netdev_ops;
13396+ clear_bit(RMNET_MODE_LLP_IP, ð_dev->flags);
13397+ set_bit(RMNET_MODE_LLP_ETH, ð_dev->flags);
13398+ DBG(eth_dev, "[%s] ioctl(): set Ethernet proto mode\n",
13399+ dev->name);
13400+ }
13401+ if (test_bit(RMNET_MODE_LLP_ETH, ð_dev->flags))
13402+ rc = 0;
13403+ break;
13404+
13405+ case RMNET_IOCTL_SET_LLP_IP: /* Set RAWIP protocol*/
13406+ /* Perform IP config only if in Ethernet mode currently*/
13407+ if (test_bit(RMNET_MODE_LLP_ETH, ð_dev->flags)) {
13408+ /* Undo config done in ether_setup() */
13409+ dev->header_ops = 0; /* No header */
13410+ dev->type = ARPHRD_RAWIP;
13411+ dev->hard_header_len = 0;
13412+ dev->mtu = prev_mtu;
13413+ dev->addr_len = 0;
13414+ dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST);
13415+ dev->netdev_ops = ð_netdev_ops_ip;
13416+ clear_bit(RMNET_MODE_LLP_ETH, ð_dev->flags);
13417+ set_bit(RMNET_MODE_LLP_IP, ð_dev->flags);
13418+ DBG(eth_dev, "[%s] ioctl(): set IP protocol mode\n",
13419+ dev->name);
13420+ }
13421+ if (test_bit(RMNET_MODE_LLP_IP, ð_dev->flags))
13422+ rc = 0;
13423+ break;
13424+
13425+ case RMNET_IOCTL_GET_LLP: /* Get link protocol state */
13426+ state = eth_dev->flags & (RMNET_MODE_LLP_ETH
13427+ | RMNET_MODE_LLP_IP);
13428+ if (copy_to_user(addr, &state, sizeof(state)))
13429+ break;
13430+ rc = 0;
13431+ break;
13432+
13433+ case RMNET_IOCTL_SET_RX_HEADROOM: /* Set RX headroom */
13434+ if (copy_from_user(ð_dev->rx_needed_headroom, addr,
13435+ sizeof(eth_dev->rx_needed_headroom)))
13436+ break;
13437+ DBG(eth_dev, "[%s] ioctl(): set RX HEADROOM: %x\n",
13438+ dev->name, eth_dev->rx_needed_headroom);
13439+ rc = 0;
13440+ break;
13441+
13442+ case RMNET_IOCTL_EXTENDED:
13443+ rc = rmnet_ioctl_extended(dev, ifr);
13444+ break;
13445+
13446+ default:
13447+ pr_err("[%s] error: ioctl called for unsupported cmd[%d]",
13448+ dev->name, cmd);
13449+ rc = -EINVAL;
13450+ }
13451+
13452+ DBG(eth_dev, "[%s] %s: cmd=0x%x opmode old=0x%08x new=0x%08lx\n",
13453+ dev->name, __func__, cmd, old_opmode, eth_dev->flags);
13454+
13455+ return rc;
13456+}
13457+
13458 static struct device_type gadget_type = {
13459 .name = "gadget",
13460 };
13461
13462+static int gether_cpufreq_notifier_cb(struct notifier_block *nfb,
13463+ unsigned long event, void *data)
13464+{
13465+ struct cpufreq_policy *policy = data;
13466+ unsigned int cpu = policy->cpu;
13467+ struct eth_dev *dev = container_of(nfb, struct eth_dev,
13468+ cpufreq_notifier);
13469+
13470+ if (!min_cpu_freq)
13471+ return NOTIFY_OK;
13472+
13473+ switch (event) {
13474+ case CPUFREQ_ADJUST:
13475+ pr_debug("%s: cpu:%u\n", __func__, cpu);
13476+
13477+ if (dev->state == ETH_START)
13478+ cpufreq_verify_within_limits(policy,
13479+ min_cpu_freq, UINT_MAX);
13480+
13481+ break;
13482+ }
13483+
13484+ return NOTIFY_OK;
13485+}
13486+
13487+static void update_cpu_policy_w(struct work_struct *work)
13488+{
13489+ int i;
13490+
13491+ for_each_online_cpu(i)
13492+ cpufreq_update_policy(i);
13493+}
13494+
13495 /**
13496 * gether_setup_name - initialize one ethernet-over-usb link
13497 * @g: gadget to associated with these links
13498@@ -1170,49 +1594,26 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g, u8 ethaddr[ETH_ALEN],
13499 spin_lock_init(&dev->lock);
13500 spin_lock_init(&dev->req_lock);
13501 INIT_WORK(&dev->work, eth_work);
13502+ INIT_WORK(&dev->rx_work, process_rx_w);
13503+ INIT_WORK(&dev->tx_work, process_tx_w);
13504 INIT_LIST_HEAD(&dev->tx_reqs);
13505 INIT_LIST_HEAD(&dev->rx_reqs);
13506- skb_queue_head_init(&dev->rx_frames);
13507+ INIT_WORK(&dev->cpu_policy_w, update_cpu_policy_w);
13508
13509-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
13510- spin_lock_init(&dev->req_rx_lock);
13511- dev->rx_workqueue = create_workqueue("rx_ether_queue");
13512- if (dev->rx_workqueue == NULL)
13513- pr_err("rx_ether_queue creation fail once\n");
13514-#endif
13515+ skb_queue_head_init(&dev->rx_frames);
13516+ skb_queue_head_init(&dev->tx_skb_q);
13517
13518-#ifdef CONFIG_BRCM_NETCONSOLE
13519- usb_eventqueue_init(&dev->usbevent_queue);
13520-#endif
13521 /* network device setup */
13522 dev->net = net;
13523 snprintf(net->name, sizeof(net->name), "%s%%d", netname);
13524
13525-#if 0 /* We use the fixed host MAC address for USB logging. */
13526 if (get_ether_addr(dev_addr, net->dev_addr))
13527 dev_warn(&g->dev,
13528 "using random %s ethernet address\n", "self");
13529 if (get_ether_addr(host_addr, dev->host_mac))
13530 dev_warn(&g->dev,
13531 "using random %s ethernet address\n", "host");
13532-#else
13533- dev_warn(&g->dev,
13534- "using fixed %s ethernet address\n", "self");
13535- net->dev_addr[0] = 0x22;
13536- net->dev_addr[1] = 0x33;
13537- net->dev_addr[2] = 0x44;
13538- net->dev_addr[3] = 0x55;
13539- net->dev_addr[4] = 0x66;
13540- net->dev_addr[5] = 0x77;
13541- dev_warn(&g->dev,
13542- "using fixed %s ethernet address\n", "host");
13543- dev->host_mac[0] = 0xaa;
13544- dev->host_mac[1] = 0xbb;
13545- dev->host_mac[2] = 0xcc;
13546- dev->host_mac[3] = 0xdd;
13547- dev->host_mac[4] = 0xee;
13548- dev->host_mac[5] = 0xff;
13549-#endif
13550+
13551 if (ethaddr)
13552 memcpy(ethaddr, dev->host_mac, ETH_ALEN);
13553
13554@@ -1220,6 +1621,9 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g, u8 ethaddr[ETH_ALEN],
13555
13556 SET_ETHTOOL_OPS(net, &ops);
13557
13558+ /* set operation mode to eth by default */
13559+ set_bit(RMNET_MODE_LLP_ETH, &dev->flags);
13560+
13561 dev->gadget = g;
13562 SET_NETDEV_DEV(net, &g->dev);
13563 SET_NETDEV_DEVTYPE(net, &gadget_type);
13564@@ -1238,6 +1642,12 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g, u8 ethaddr[ETH_ALEN],
13565 * - tx queueing enabled if open *and* carrier is "on"
13566 */
13567 netif_carrier_off(net);
13568+ uether_debugfs_init(dev, netname);
13569+
13570+ dev->cpufreq_notifier.notifier_call =
13571+ gether_cpufreq_notifier_cb;
13572+ cpufreq_register_notifier(&dev->cpufreq_notifier,
13573+ CPUFREQ_POLICY_NOTIFIER);
13574 }
13575
13576 return dev;
13577@@ -1251,20 +1661,56 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g, u8 ethaddr[ETH_ALEN],
13578 */
13579 void gether_cleanup(struct eth_dev *dev)
13580 {
13581- pr_info("%s\n", __func__);
13582+ int i;
13583
13584 if (!dev)
13585 return;
13586
13587+ /* make sure cpu boost is set to normal again */
13588+ dev->state = ETH_UNDEFINED;
13589+ cancel_work_sync(&dev->cpu_policy_w);
13590+ for_each_online_cpu(i)
13591+ cpufreq_update_policy(i);
13592+
13593+ cpufreq_unregister_notifier(&dev->cpufreq_notifier,
13594+ CPUFREQ_POLICY_NOTIFIER);
13595+
13596+ uether_debugfs_exit(dev);
13597 unregister_netdev(dev->net);
13598 flush_work(&dev->work);
13599-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
13600- flush_workqueue(dev->rx_workqueue);
13601- destroy_workqueue(dev->rx_workqueue);
13602-#endif
13603 free_netdev(dev->net);
13604 }
13605
13606+void gether_update_dl_max_xfer_size(struct gether *link, uint32_t s)
13607+{
13608+ struct eth_dev *dev = link->ioport;
13609+ unsigned long flags;
13610+
13611+ spin_lock_irqsave(&dev->lock, flags);
13612+ dev->dl_max_xfer_size = s;
13613+ spin_unlock_irqrestore(&dev->lock, flags);
13614+}
13615+
13616+void gether_enable_sg(struct gether *link, bool enable)
13617+{
13618+ struct eth_dev *dev = link->ioport;
13619+
13620+ dev->sg_enabled = enable ? dev->gadget->sg_supported : false;
13621+}
13622+
13623+void gether_update_dl_max_pkts_per_xfer(struct gether *link, uint32_t n)
13624+{
13625+ struct eth_dev *dev = link->ioport;
13626+ unsigned long flags;
13627+
13628+ if (n > DL_MAX_PKTS_PER_XFER)
13629+ n = DL_MAX_PKTS_PER_XFER;
13630+
13631+ spin_lock_irqsave(&dev->lock, flags);
13632+ dev->dl_max_pkts_per_xfer = n;
13633+ spin_unlock_irqrestore(&dev->lock, flags);
13634+}
13635+
13636 /**
13637 * gether_connect - notify network layer that USB link is active
13638 * @link: the USB link, set up with endpoints, descriptors matching
13639@@ -1285,12 +1731,24 @@ struct net_device *gether_connect(struct gether *link)
13640 {
13641 struct eth_dev *dev = link->ioport;
13642 int result = 0;
13643-
13644- pr_info("%s\n", __func__);
13645+ bool wait_for_rx_trigger;
13646
13647 if (!dev)
13648 return ERR_PTR(-EINVAL);
13649
13650+ /* if scatter/gather or sg is supported then headers can be part of
13651+ * req->buf which is allocated later
13652+ */
13653+ if (!dev->sg_enabled) {
13654+ link->header = kzalloc(sizeof(struct rndis_packet_msg_type),
13655+ GFP_ATOMIC);
13656+ if (!link->header) {
13657+ pr_err("RNDIS header memory allocation failed.\n");
13658+ result = -ENOMEM;
13659+ goto fail;
13660+ }
13661+ }
13662+
13663 link->in_ep->driver_data = dev;
13664 result = usb_ep_enable(link->in_ep);
13665 if (result != 0) {
13666@@ -1307,29 +1765,26 @@ struct net_device *gether_connect(struct gether *link)
13667 goto fail1;
13668 }
13669
13670+ dev->header_len = link->header_len;
13671+ dev->unwrap = link->unwrap;
13672+ dev->wrap = link->wrap;
13673+ dev->ul_max_pkts_per_xfer = link->ul_max_pkts_per_xfer;
13674+ dev->dl_max_pkts_per_xfer = link->dl_max_pkts_per_xfer;
13675+ dev->dl_max_xfer_size = link->dl_max_xfer_size;
13676+ dev->rx_trigger_enabled = link->rx_trigger_enabled;
13677+
13678 if (result == 0)
13679 result = alloc_requests(dev, link, qlen(dev->gadget));
13680
13681 if (result == 0) {
13682-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
13683- if (link->is_fixed) { /* NCM */
13684- max_skb_buf_no = UETH_RX_SKB_THRESH_NCM;
13685- max_skb_buf_sz = link->fixed_out_len;
13686- } else {
13687- max_skb_buf_no = UETH_RX_SKB_THRESHOLD;
13688- max_skb_buf_sz = MAX_RX_SKB_SIZE;
13689- }
13690- pr_info("USB Ether: It is in SKB prealloc mode!\n");
13691- prealloc_rx_skbs();
13692-#endif
13693+
13694 dev->zlp = link->is_zlp_ok;
13695 DBG(dev, "qlen %d\n", qlen(dev->gadget));
13696
13697- dev->header_len = link->header_len;
13698- dev->unwrap = link->unwrap;
13699- dev->wrap = link->wrap;
13700-
13701 spin_lock(&dev->lock);
13702+ dev->tx_skb_hold_count = 0;
13703+ dev->no_tx_req_used = 0;
13704+ dev->tx_req_bufsize = 0;
13705 dev->port_usb = link;
13706 if (netif_running(dev->net)) {
13707 if (link->open)
13708@@ -1341,7 +1796,11 @@ struct net_device *gether_connect(struct gether *link)
13709 spin_unlock(&dev->lock);
13710
13711 netif_carrier_on(dev->net);
13712- if (netif_running(dev->net))
13713+
13714+ wait_for_rx_trigger = dev->rx_trigger_enabled &&
13715+ !link->rx_triggered;
13716+
13717+ if (netif_running(dev->net) && !wait_for_rx_trigger)
13718 eth_start(dev, GFP_ATOMIC);
13719
13720 /* on error, disable any endpoints */
13721@@ -1350,10 +1809,15 @@ struct net_device *gether_connect(struct gether *link)
13722 fail1:
13723 (void) usb_ep_disable(link->in_ep);
13724 }
13725-fail0:
13726+
13727 /* caller is responsible for cleanup on error */
13728- if (result < 0)
13729+ if (result < 0) {
13730+fail0:
13731+ kfree(link->header);
13732+fail:
13733 return ERR_PTR(result);
13734+ }
13735+
13736 return dev->net;
13737 }
13738
13739@@ -1373,17 +1837,15 @@ void gether_disconnect(struct gether *link)
13740 {
13741 struct eth_dev *dev = link->ioport;
13742 struct usb_request *req;
13743+ struct sk_buff *skb;
13744
13745- WARN_ON(!dev);
13746 if (!dev)
13747 return;
13748
13749 DBG(dev, "%s\n", __func__);
13750- pr_info("%s\n", __func__);
13751
13752-#ifdef CONFIG_BRCM_NETCONSOLE
13753- defer_kevent(dev, WORK_BRCM_NETCONSOLE_OFF);
13754-#endif
13755+ dev->state = ETH_UNDEFINED;
13756+ queue_work(uether_wq, &dev->cpu_policy_w);
13757
13758 netif_stop_queue(dev->net);
13759 netif_carrier_off(dev->net);
13760@@ -1400,10 +1862,28 @@ void gether_disconnect(struct gether *link)
13761 list_del(&req->list);
13762
13763 spin_unlock(&dev->req_lock);
13764+ if (link->multi_pkt_xfer ||
13765+ dev->sg_enabled) {
13766+ kfree(req->buf);
13767+ req->buf = NULL;
13768+ }
13769+ if (dev->sg_enabled) {
13770+ kfree(req->context);
13771+ kfree(req->sg);
13772+ }
13773+
13774 usb_ep_free_request(link->in_ep, req);
13775 spin_lock(&dev->req_lock);
13776 }
13777+
13778+ /* Free rndis header buffer memory */
13779+ if (!dev->sg_enabled)
13780+ kfree(link->header);
13781+ link->header = NULL;
13782 spin_unlock(&dev->req_lock);
13783+
13784+ skb_queue_purge(&dev->tx_skb_q);
13785+
13786 link->in_ep->driver_data = NULL;
13787 link->in_ep->desc = NULL;
13788
13789@@ -1419,18 +1899,143 @@ void gether_disconnect(struct gether *link)
13790 spin_lock(&dev->req_lock);
13791 }
13792 spin_unlock(&dev->req_lock);
13793+
13794+ spin_lock(&dev->rx_frames.lock);
13795+ while ((skb = __skb_dequeue(&dev->rx_frames)))
13796+ dev_kfree_skb_any(skb);
13797+ spin_unlock(&dev->rx_frames.lock);
13798+
13799 link->out_ep->driver_data = NULL;
13800 link->out_ep->desc = NULL;
13801
13802+ pr_debug("%s(): tx_throttle count= %lu", __func__,
13803+ dev->tx_throttle);
13804+ /* reset tx_throttle count */
13805+ dev->tx_throttle = 0;
13806+ dev->rx_throttle = 0;
13807+
13808 /* finish forgetting about this USB link episode */
13809 dev->header_len = 0;
13810 dev->unwrap = NULL;
13811 dev->wrap = NULL;
13812+ dev->rx_trigger_enabled = 0;
13813
13814 spin_lock(&dev->lock);
13815 dev->port_usb = NULL;
13816 spin_unlock(&dev->lock);
13817-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
13818- ueth_rx_skb_queue_purge(&skb_rx_pool);
13819-#endif
13820 }
13821+
13822+int gether_up(struct gether *link)
13823+{
13824+ struct eth_dev *dev = link->ioport;
13825+
13826+ if (dev && netif_carrier_ok(dev->net))
13827+ eth_start(dev, GFP_KERNEL);
13828+
13829+ return 0;
13830+}
13831+
13832+
13833+static int uether_stat_show(struct seq_file *s, void *unused)
13834+{
13835+ struct eth_dev *dev = s->private;
13836+ int ret = 0;
13837+ int i;
13838+
13839+ if (dev) {
13840+ seq_printf(s, "rx_throttle = %lu\n",
13841+ dev->rx_throttle);
13842+ seq_printf(s, "tx_qlen=%u tx_throttle = %lu\n aggr count:",
13843+ dev->tx_skb_q.qlen,
13844+ dev->tx_throttle);
13845+ for (i = 0; i < DL_MAX_PKTS_PER_XFER; i++)
13846+ seq_printf(s, "%u\t", dev->tx_aggr_cnt[i]);
13847+
13848+ seq_printf(s, "\nloop_brk_cnt = %u\n tx_pkts_rcvd=%u\n",
13849+ dev->loop_brk_cnt,
13850+ dev->tx_pkts_rcvd);
13851+ }
13852+
13853+ return ret;
13854+}
13855+
13856+static int uether_open(struct inode *inode, struct file *file)
13857+{
13858+ return single_open(file, uether_stat_show, inode->i_private);
13859+}
13860+
13861+static ssize_t uether_stat_reset(struct file *file,
13862+ const char __user *ubuf, size_t count, loff_t *ppos)
13863+{
13864+ struct seq_file *s = file->private_data;
13865+ struct eth_dev *dev = s->private;
13866+ unsigned long flags;
13867+
13868+ spin_lock_irqsave(&dev->lock, flags);
13869+ /* Reset tx_throttle */
13870+ dev->tx_throttle = 0;
13871+ dev->rx_throttle = 0;
13872+ spin_unlock_irqrestore(&dev->lock, flags);
13873+ return count;
13874+}
13875+
13876+const struct file_operations uether_stats_ops = {
13877+ .open = uether_open,
13878+ .read = seq_read,
13879+ .write = uether_stat_reset,
13880+};
13881+
13882+static void uether_debugfs_init(struct eth_dev *dev, const char *name)
13883+{
13884+ struct dentry *uether_dent;
13885+ struct dentry *uether_dfile;
13886+
13887+ uether_dent = debugfs_create_dir(name, 0);
13888+ if (IS_ERR(uether_dent))
13889+ return;
13890+ dev->uether_dent = uether_dent;
13891+
13892+ uether_dfile = debugfs_create_file("status", S_IRUGO | S_IWUSR,
13893+ uether_dent, dev, &uether_stats_ops);
13894+ if (!uether_dfile || IS_ERR(uether_dfile))
13895+ debugfs_remove(uether_dent);
13896+ dev->uether_dfile = uether_dfile;
13897+}
13898+
13899+static void uether_debugfs_exit(struct eth_dev *dev)
13900+{
13901+ debugfs_remove(dev->uether_dfile);
13902+ debugfs_remove(dev->uether_dent);
13903+ dev->uether_dent = NULL;
13904+ dev->uether_dfile = NULL;
13905+}
13906+
13907+static int __init gether_init(void)
13908+{
13909+ uether_wq = alloc_workqueue("uether", WQ_CPU_INTENSIVE, 1);
13910+ if (!uether_wq) {
13911+ pr_err("%s: Unable to create workqueue: uether\n", __func__);
13912+ return -ENOMEM;
13913+ }
13914+
13915+ uether_tx_wq = alloc_workqueue("uether_tx",
13916+ WQ_CPU_INTENSIVE | WQ_UNBOUND, 1);
13917+ if (!uether_tx_wq) {
13918+ destroy_workqueue(uether_wq);
13919+ pr_err("%s: Unable to create workqueue: uether\n", __func__);
13920+ return -ENOMEM;
13921+ }
13922+
13923+ return 0;
13924+}
13925+module_init(gether_init);
13926+
13927+static void __exit gether_exit(void)
13928+{
13929+ destroy_workqueue(uether_tx_wq);
13930+ destroy_workqueue(uether_wq);
13931+
13932+}
13933+module_exit(gether_exit);
13934+MODULE_DESCRIPTION("ethernet over USB driver");
13935+MODULE_LICENSE("GPL v2");
13936diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
13937index 886c500..4b6064e 100644
13938--- a/drivers/usb/gadget/u_ether.h
13939+++ b/drivers/usb/gadget/u_ether.h
13940@@ -54,6 +54,13 @@ struct gether {
13941 bool is_fixed;
13942 u32 fixed_out_len;
13943 u32 fixed_in_len;
13944+
13945+ unsigned ul_max_pkts_per_xfer;
13946+ uint32_t dl_max_pkts_per_xfer;
13947+ uint32_t dl_max_xfer_size;
13948+ bool multi_pkt_xfer;
13949+ bool rx_trigger_enabled;
13950+ bool rx_triggered;
13951 struct sk_buff *(*wrap)(struct gether *port,
13952 struct sk_buff *skb);
13953 int (*unwrap)(struct gether *port,
13954@@ -63,6 +70,8 @@ struct gether {
13955 /* called on network open/close */
13956 void (*open)(struct gether *);
13957 void (*close)(struct gether *);
13958+ struct rndis_packet_msg_type *header;
13959+
13960 };
13961
13962 #define DEFAULT_FILTER (USB_CDC_PACKET_TYPE_BROADCAST \
13963@@ -98,6 +107,10 @@ void gether_cleanup(struct eth_dev *dev);
13964 /* connect/disconnect is handled by individual functions */
13965 struct net_device *gether_connect(struct gether *);
13966 void gether_disconnect(struct gether *);
13967+int gether_up(struct gether *);
13968+void gether_update_dl_max_pkts_per_xfer(struct gether *link, uint32_t n);
13969+void gether_update_dl_max_xfer_size(struct gether *link, uint32_t s);
13970+void gether_enable_sg(struct gether *link, bool);
13971
13972 /* Some controllers can't support CDC Ethernet (ECM) ... */
13973 static inline bool can_support_ecm(struct usb_gadget *gadget)
13974@@ -125,6 +138,7 @@ int eem_bind_config(struct usb_configuration *c, struct eth_dev *dev);
13975
13976 int rndis_bind_config_vendor(struct usb_configuration *c, u8 ethaddr[ETH_ALEN],
13977 u32 vendorID, const char *manufacturer, struct eth_dev *dev);
13978+int rndis_rx_trigger(void);
13979
13980 #else
13981
13982@@ -135,6 +149,12 @@ rndis_bind_config_vendor(struct usb_configuration *c, u8 ethaddr[ETH_ALEN],
13983 return 0;
13984 }
13985
13986+static inline int
13987+rndis_rx_trigger(void)
13988+{
13989+ return 0;
13990+}
13991+
13992 #endif
13993
13994 /**
13995@@ -155,12 +175,4 @@ static inline int rndis_bind_config(struct usb_configuration *c,
13996 return rndis_bind_config_vendor(c, ethaddr, 0, NULL, dev);
13997 }
13998
13999-#ifdef CONFIG_BRCM_NETCONSOLE
14000-extern void brcm_current_netcon_status(unsigned char status);
14001-extern unsigned char brcm_get_netcon_status(void);
14002-#endif
14003-#ifdef CONFIG_USB_ETH_SKB_ALLOC_OPTIMIZATION
14004-extern void ncm_ntb_out_size(u32 ntb_out_size);
14005-#endif
14006-
14007 #endif /* __U_ETHER_H */
14008diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
14009index 2fe5fd9..030a47e 100644
14010--- a/drivers/usb/gadget/u_serial.c
14011+++ b/drivers/usb/gadget/u_serial.c
14012@@ -4,6 +4,7 @@
14013 * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
14014 * Copyright (C) 2008 David Brownell
14015 * Copyright (C) 2008 by Nokia Corporation
14016+ * Copyright (c) 2013-2014 The Linux Foundation. All rights reserved.
14017 *
14018 * This code also borrows from usbserial.c, which is
14019 * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
14020@@ -27,11 +28,11 @@
14021 #include <linux/slab.h>
14022 #include <linux/export.h>
14023 #include <linux/module.h>
14024+#include <linux/debugfs.h>
14025+#include <linux/workqueue.h>
14026
14027 #include "u_serial.h"
14028
14029-static struct acm_logging_callbacks *acm_logging_cb;
14030-
14031
14032 /*
14033 * This component encapsulates the TTY layer glue needed to provide basic
14034@@ -82,9 +83,14 @@ static struct acm_logging_callbacks *acm_logging_cb;
14035 * next layer of buffering. For TX that's a circular buffer; for RX
14036 * consider it a NOP. A third layer is provided by the TTY code.
14037 */
14038-#define QUEUE_SIZE 16
14039+#define TX_QUEUE_SIZE 8
14040+#define TX_BUF_SIZE 4096
14041 #define WRITE_BUF_SIZE 8192 /* TX only */
14042
14043+#define RX_QUEUE_SIZE 8
14044+#define RX_BUF_SIZE 4096
14045+
14046+
14047 /* circular buffer */
14048 struct gs_buf {
14049 unsigned buf_size;
14050@@ -111,11 +117,8 @@ struct gs_port {
14051 int read_allocated;
14052 struct list_head read_queue;
14053 unsigned n_read;
14054-#ifndef CONFIG_USE_WORKQ_PUSH
14055- struct tasklet_struct push;
14056-#else
14057- struct work_struct push;
14058-#endif
14059+ struct work_struct push;
14060+
14061 struct list_head write_pool;
14062 int write_started;
14063 int write_allocated;
14064@@ -124,6 +127,10 @@ struct gs_port {
14065
14066 /* REVISIT this state ... */
14067 struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */
14068+ unsigned long nbytes_from_host;
14069+ unsigned long nbytes_to_tty;
14070+ unsigned long nbytes_from_tty;
14071+ unsigned long nbytes_to_host;
14072 };
14073
14074 static struct portmaster {
14075@@ -131,6 +138,8 @@ static struct portmaster {
14076 struct gs_port *port;
14077 } ports[MAX_U_SERIAL_PORTS];
14078
14079+static struct workqueue_struct *gserial_wq;
14080+
14081 #define GS_CLOSE_TIMEOUT 15 /* seconds */
14082
14083
14084@@ -366,21 +375,50 @@ __releases(&port->port_lock)
14085 __acquires(&port->port_lock)
14086 */
14087 {
14088- struct list_head *pool = &port->write_pool;
14089- struct usb_ep *in = port->port_usb->in;
14090+ struct list_head *pool;
14091+ struct usb_ep *in;
14092 int status = 0;
14093+ static long prev_len;
14094 bool do_tty_wake = false;
14095
14096+ if (!port || !port->port_usb) {
14097+ pr_err("Error - port or port->usb is NULL.");
14098+ return -EIO;
14099+ }
14100+
14101+ pool = &port->write_pool;
14102+ in = port->port_usb->in;
14103+
14104 while (!list_empty(pool)) {
14105 struct usb_request *req;
14106 int len;
14107
14108- if (port->write_started >= QUEUE_SIZE)
14109+ if (port->write_started >= TX_QUEUE_SIZE)
14110 break;
14111
14112 req = list_entry(pool->next, struct usb_request, list);
14113- len = gs_send_packet(port, req->buf, in->maxpacket);
14114+ len = gs_send_packet(port, req->buf, TX_BUF_SIZE);
14115 if (len == 0) {
14116+ /* Queue zero length packet explicitly to make it
14117+ * work with UDCs which don't support req->zero flag
14118+ */
14119+ if (prev_len && (prev_len % in->maxpacket == 0)) {
14120+ req->length = 0;
14121+ list_del(&req->list);
14122+ spin_unlock(&port->port_lock);
14123+ status = usb_ep_queue(in, req, GFP_ATOMIC);
14124+ spin_lock(&port->port_lock);
14125+ if (!port->port_usb) {
14126+ gs_free_req(in, req);
14127+ break;
14128+ }
14129+ if (status) {
14130+ printk(KERN_ERR "%s: %s err %d\n",
14131+ __func__, "queue", status);
14132+ list_add(&req->list, pool);
14133+ }
14134+ prev_len = 0;
14135+ }
14136 wake_up_interruptible(&port->drain_wait);
14137 break;
14138 }
14139@@ -388,7 +426,6 @@ __acquires(&port->port_lock)
14140
14141 req->length = len;
14142 list_del(&req->list);
14143- req->zero = (gs_buf_data_avail(&port->port_write_buf) == 0);
14144
14145 pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n",
14146 port->port_num, len, *((u8 *)req->buf),
14147@@ -404,19 +441,27 @@ __acquires(&port->port_lock)
14148 spin_unlock(&port->port_lock);
14149 status = usb_ep_queue(in, req, GFP_ATOMIC);
14150 spin_lock(&port->port_lock);
14151-
14152+ /*
14153+ * If port_usb is NULL, gserial disconnect is called
14154+ * while the spinlock is dropped and all requests are
14155+ * freed. Free the current request here.
14156+ */
14157+ if (!port->port_usb) {
14158+ do_tty_wake = false;
14159+ gs_free_req(in, req);
14160+ break;
14161+ }
14162 if (status) {
14163 pr_debug("%s: %s %s err %d\n",
14164 __func__, "queue", in->name, status);
14165 list_add(&req->list, pool);
14166 break;
14167 }
14168+ prev_len = req->length;
14169+ port->nbytes_from_tty += req->length;
14170
14171 port->write_started++;
14172
14173- /* abort immediately after disconnect */
14174- if (!port->port_usb)
14175- break;
14176 }
14177
14178 if (do_tty_wake && port->port.tty)
14179@@ -433,8 +478,17 @@ __releases(&port->port_lock)
14180 __acquires(&port->port_lock)
14181 */
14182 {
14183- struct list_head *pool = &port->read_pool;
14184- struct usb_ep *out = port->port_usb->out;
14185+ struct list_head *pool;
14186+ struct usb_ep *out;
14187+ unsigned started = 0;
14188+
14189+ if (!port || !port->port_usb) {
14190+ pr_err("Error - port or port->usb is NULL.");
14191+ return -EIO;
14192+ }
14193+
14194+ pool = &port->read_pool;
14195+ out = port->port_usb->out;
14196
14197 while (!list_empty(pool)) {
14198 struct usb_request *req;
14199@@ -446,12 +500,12 @@ __acquires(&port->port_lock)
14200 if (!tty)
14201 break;
14202
14203- if (port->read_started >= QUEUE_SIZE)
14204+ if (port->read_started >= RX_QUEUE_SIZE)
14205 break;
14206
14207 req = list_entry(pool->next, struct usb_request, list);
14208 list_del(&req->list);
14209- req->length = out->maxpacket;
14210+ req->length = RX_BUF_SIZE;
14211
14212 /* drop lock while we call out; the controller driver
14213 * may need to call us back (e.g. for disconnect)
14214@@ -459,7 +513,16 @@ __acquires(&port->port_lock)
14215 spin_unlock(&port->port_lock);
14216 status = usb_ep_queue(out, req, GFP_ATOMIC);
14217 spin_lock(&port->port_lock);
14218-
14219+ /*
14220+ * If port_usb is NULL, gserial disconnect is called
14221+ * while the spinlock is dropped and all requests are
14222+ * freed. Free the current request here.
14223+ */
14224+ if (!port->port_usb) {
14225+ started = 0;
14226+ gs_free_req(out, req);
14227+ break;
14228+ }
14229 if (status) {
14230 pr_debug("%s: %s %s err %d\n",
14231 __func__, "queue", out->name, status);
14232@@ -468,9 +531,6 @@ __acquires(&port->port_lock)
14233 }
14234 port->read_started++;
14235
14236- /* abort immediately after disconnect */
14237- if (!port->port_usb)
14238- break;
14239 }
14240 return port->read_started;
14241 }
14242@@ -485,26 +545,14 @@ __acquires(&port->port_lock)
14243 * So QUEUE_SIZE packets plus however many the FIFO holds (usually two)
14244 * can be buffered before the TTY layer's buffers (currently 64 KB).
14245 */
14246-#ifndef CONFIG_USE_WORKQ_PUSH
14247-static void gs_rx_push(unsigned long _port)
14248-{
14249- struct gs_port *port = (void *)_port;
14250- struct list_head *queue = &port->read_queue;
14251-#else
14252-static void gs_rx_push(struct work_struct *work)
14253+static void gs_rx_push(struct work_struct *w)
14254 {
14255- struct gs_port *port;
14256- struct list_head *queue;
14257-#endif
14258+ struct gs_port *port = container_of(w, struct gs_port, push);
14259 struct tty_struct *tty;
14260+ struct list_head *queue = &port->read_queue;
14261 bool disconnect = false;
14262 bool do_push = false;
14263
14264-#ifdef CONFIG_USE_WORKQ_PUSH
14265- port = container_of(work, struct gs_port, push);
14266- queue = &port->read_queue;
14267-#endif
14268-
14269 /* hand any queued data to the tty */
14270 spin_lock_irq(&port->port_lock);
14271 tty = port->port.tty;
14272@@ -549,6 +597,7 @@ static void gs_rx_push(struct work_struct *work)
14273
14274 count = tty_insert_flip_string(&port->port, packet,
14275 size);
14276+ port->nbytes_to_tty += count;
14277 if (count)
14278 do_push = true;
14279 if (count != size) {
14280@@ -572,23 +621,18 @@ static void gs_rx_push(struct work_struct *work)
14281 if (do_push)
14282 tty_flip_buffer_push(&port->port);
14283
14284-
14285 /* We want our data queue to become empty ASAP, keeping data
14286 * in the tty and ldisc (not here). If we couldn't push any
14287 * this time around, there may be trouble unless there's an
14288 * implicit tty_unthrottle() call on its way...
14289 *
14290- * REVISIT we should probably add a timer to keep the tasklet
14291+ * REVISIT we should probably add a timer to keep the work queue
14292 * from starving ... but it's not clear that case ever happens.
14293 */
14294 if (!list_empty(queue) && tty) {
14295 if (!test_bit(TTY_THROTTLED, &tty->flags)) {
14296 if (do_push)
14297-#ifndef CONFIG_USE_WORKQ_PUSH
14298- tasklet_schedule(&port->push);
14299-#else
14300- schedule_work(&port->push);
14301-#endif
14302+ queue_work(gserial_wq, &port->push);
14303 else
14304 pr_warning(PREFIX "%d: RX not scheduled?\n",
14305 port->port_num);
14306@@ -605,29 +649,23 @@ static void gs_rx_push(struct work_struct *work)
14307 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
14308 {
14309 struct gs_port *port = ep->driver_data;
14310-
14311- if (WARN_ON(!port))
14312- return;
14313+ unsigned long flags;
14314
14315 /* Queue all received data until the tty layer is ready for it. */
14316- spin_lock(&port->port_lock);
14317+ spin_lock_irqsave(&port->port_lock, flags);
14318+ port->nbytes_from_host += req->actual;
14319 list_add_tail(&req->list, &port->read_queue);
14320-#ifndef CONFIG_USE_WORKQ_PUSH
14321- tasklet_schedule(&port->push);
14322-#else
14323- schedule_work(&port->push);
14324-#endif
14325- spin_unlock(&port->port_lock);
14326+ queue_work(gserial_wq, &port->push);
14327+ spin_unlock_irqrestore(&port->port_lock, flags);
14328 }
14329
14330 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
14331 {
14332 struct gs_port *port = ep->driver_data;
14333+ unsigned long flags;
14334
14335- if (WARN_ON(!port))
14336- return;
14337-
14338- spin_lock(&port->port_lock);
14339+ spin_lock_irqsave(&port->port_lock, flags);
14340+ port->nbytes_to_host += req->actual;
14341 list_add(&req->list, &port->write_pool);
14342 port->write_started--;
14343
14344@@ -639,7 +677,8 @@ static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
14345 /* FALL THROUGH */
14346 case 0:
14347 /* normal completion */
14348- gs_start_tx(port);
14349+ if (port->port_usb)
14350+ gs_start_tx(port);
14351 break;
14352
14353 case -ESHUTDOWN:
14354@@ -648,7 +687,7 @@ static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
14355 break;
14356 }
14357
14358- spin_unlock(&port->port_lock);
14359+ spin_unlock_irqrestore(&port->port_lock, flags);
14360 }
14361
14362 static void gs_free_requests(struct usb_ep *ep, struct list_head *head,
14363@@ -666,19 +705,20 @@ static void gs_free_requests(struct usb_ep *ep, struct list_head *head,
14364 }
14365
14366 static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
14367+ int queue_size, int req_size,
14368 void (*fn)(struct usb_ep *, struct usb_request *),
14369 int *allocated)
14370 {
14371 int i;
14372 struct usb_request *req;
14373- int n = allocated ? QUEUE_SIZE - *allocated : QUEUE_SIZE;
14374+ int n = allocated ? queue_size - *allocated : queue_size;
14375
14376 /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
14377 * do quite that many this time, don't fail ... we just won't
14378 * be as speedy as we might otherwise be.
14379 */
14380 for (i = 0; i < n; i++) {
14381- req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
14382+ req = gs_alloc_req(ep, req_size, GFP_ATOMIC);
14383 if (!req)
14384 return list_empty(head) ? -ENOMEM : 0;
14385 req->complete = fn;
14386@@ -700,24 +740,32 @@ static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
14387 */
14388 static int gs_start_io(struct gs_port *port)
14389 {
14390- struct list_head *head = &port->read_pool;
14391- struct usb_ep *ep = port->port_usb->out;
14392+ struct list_head *head;
14393+ struct usb_ep *ep;
14394 int status;
14395 unsigned started;
14396
14397+ if (!port || !port->port_usb) {
14398+ pr_err("Error - port or port->usb is NULL.");
14399+ return -EIO;
14400+ }
14401+
14402+ head = &port->read_pool;
14403+ ep = port->port_usb->out;
14404+
14405 /* Allocate RX and TX I/O buffers. We can't easily do this much
14406 * earlier (with GFP_KERNEL) because the requests are coupled to
14407 * endpoints, as are the packet sizes we'll be using. Different
14408 * configurations may use different endpoints with a given port;
14409 * and high speed vs full speed changes packet sizes too.
14410 */
14411- status = gs_alloc_requests(ep, head, gs_read_complete,
14412- &port->read_allocated);
14413+ status = gs_alloc_requests(ep, head, RX_QUEUE_SIZE, RX_BUF_SIZE,
14414+ gs_read_complete, &port->read_allocated);
14415 if (status)
14416 return status;
14417
14418 status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
14419- gs_write_complete, &port->write_allocated);
14420+ TX_QUEUE_SIZE, TX_BUF_SIZE, gs_write_complete, &port->write_allocated);
14421 if (status) {
14422 gs_free_requests(ep, head, &port->read_allocated);
14423 return status;
14424@@ -832,6 +880,11 @@ static int gs_open(struct tty_struct *tty, struct file *file)
14425 if (port->port_usb) {
14426 struct gserial *gser = port->port_usb;
14427
14428+ if (gser->flags & ASYNC_LOW_LATENCY) {
14429+ pr_debug("%s: Setting to low latency", __func__);
14430+ tty->port->low_latency = 1;
14431+ }
14432+
14433 pr_debug("gs_open: start ttyGS%d\n", port->port_num);
14434 gs_start_io(port);
14435
14436@@ -865,9 +918,6 @@ static void gs_close(struct tty_struct *tty, struct file *file)
14437 struct gs_port *port = tty->driver_data;
14438 struct gserial *gser;
14439
14440- if (WARN_ON(!port))
14441- return;
14442-
14443 spin_lock_irq(&port->port_lock);
14444
14445 if (port->port.count != 1) {
14446@@ -904,7 +954,7 @@ static void gs_close(struct tty_struct *tty, struct file *file)
14447
14448 /* Iff we're disconnected, there can be no I/O in flight so it's
14449 * ok to free the circular buffer; else just scrub it. And don't
14450- * let the push tasklet fire again until we're re-opened.
14451+ * let the push work queue fire again until we're re-opened.
14452 */
14453 if (gser == NULL)
14454 gs_buf_free(&port->port_write_buf);
14455@@ -926,16 +976,12 @@ exit:
14456
14457 static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
14458 {
14459- struct gs_port *port;
14460+ struct gs_port *port = tty->driver_data;
14461 unsigned long flags;
14462 int status;
14463
14464- if (tty->driver_data == (void *)0) {
14465- pr_warn("tty->driver_data is zero\n");
14466+ if (!port)
14467 return 0;
14468- }
14469- port = tty->driver_data;
14470-
14471 pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
14472 port->port_num, tty, count);
14473
14474@@ -956,10 +1002,9 @@ static int gs_put_char(struct tty_struct *tty, unsigned char ch)
14475 unsigned long flags;
14476 int status;
14477
14478- if (WARN_ON(!port))
14479+ if (!port)
14480 return 0;
14481-
14482- pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
14483+ pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %pf\n",
14484 port->port_num, tty, ch, __builtin_return_address(0));
14485
14486 spin_lock_irqsave(&port->port_lock, flags);
14487@@ -974,9 +1019,8 @@ static void gs_flush_chars(struct tty_struct *tty)
14488 struct gs_port *port = tty->driver_data;
14489 unsigned long flags;
14490
14491- if (WARN_ON(!port))
14492+ if (!port)
14493 return;
14494-
14495 pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
14496
14497 spin_lock_irqsave(&port->port_lock, flags);
14498@@ -991,9 +1035,8 @@ static int gs_write_room(struct tty_struct *tty)
14499 unsigned long flags;
14500 int room = 0;
14501
14502- if (WARN_ON(!port))
14503+ if (!port)
14504 return 0;
14505-
14506 spin_lock_irqsave(&port->port_lock, flags);
14507 if (port->port_usb)
14508 room = gs_buf_space_avail(&port->port_write_buf);
14509@@ -1011,9 +1054,8 @@ static int gs_chars_in_buffer(struct tty_struct *tty)
14510 unsigned long flags;
14511 int chars = 0;
14512
14513- if (WARN_ON(!port))
14514+ if (!port)
14515 return 0;
14516-
14517 spin_lock_irqsave(&port->port_lock, flags);
14518 chars = gs_buf_data_avail(&port->port_write_buf);
14519 spin_unlock_irqrestore(&port->port_lock, flags);
14520@@ -1030,7 +1072,11 @@ static void gs_unthrottle(struct tty_struct *tty)
14521 struct gs_port *port = tty->driver_data;
14522 unsigned long flags;
14523
14524- if (WARN_ON(!port))
14525+ /*
14526+ * tty's driver data is set to NULL during port close. Nothing
14527+ * to do here.
14528+ */
14529+ if (!port)
14530 return;
14531
14532 spin_lock_irqsave(&port->port_lock, flags);
14533@@ -1039,11 +1085,7 @@ static void gs_unthrottle(struct tty_struct *tty)
14534 * rts/cts, or other handshaking with the host, but if the
14535 * read queue backs up enough we'll be NAKing OUT packets.
14536 */
14537-#ifndef CONFIG_USE_WORKQ_PUSH
14538- tasklet_schedule(&port->push);
14539-#else
14540- schedule_work(&port->push);
14541-#endif
14542+ queue_work(gserial_wq, &port->push);
14543 pr_vdebug(PREFIX "%d: unthrottle\n", port->port_num);
14544 }
14545 spin_unlock_irqrestore(&port->port_lock, flags);
14546@@ -1055,9 +1097,8 @@ static int gs_break_ctl(struct tty_struct *tty, int duration)
14547 int status = 0;
14548 struct gserial *gser;
14549
14550- if (WARN_ON(!port))
14551+ if (!port)
14552 return 0;
14553-
14554 pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d)\n",
14555 port->port_num, duration);
14556
14557@@ -1070,6 +1111,81 @@ static int gs_break_ctl(struct tty_struct *tty, int duration)
14558 return status;
14559 }
14560
14561+static int gs_tiocmget(struct tty_struct *tty)
14562+{
14563+ struct gs_port *port = tty->driver_data;
14564+ struct gserial *gser;
14565+ unsigned int result = 0;
14566+
14567+ if (!port)
14568+ return -ENODEV;
14569+ spin_lock_irq(&port->port_lock);
14570+ gser = port->port_usb;
14571+ if (!gser) {
14572+ result = -ENODEV;
14573+ goto fail;
14574+ }
14575+
14576+ if (gser->get_dtr)
14577+ result |= (gser->get_dtr(gser) ? TIOCM_DTR : 0);
14578+
14579+ if (gser->get_rts)
14580+ result |= (gser->get_rts(gser) ? TIOCM_RTS : 0);
14581+
14582+ if (gser->serial_state & TIOCM_CD)
14583+ result |= TIOCM_CD;
14584+
14585+ if (gser->serial_state & TIOCM_RI)
14586+ result |= TIOCM_RI;
14587+fail:
14588+ spin_unlock_irq(&port->port_lock);
14589+ return result;
14590+}
14591+
14592+static int gs_tiocmset(struct tty_struct *tty,
14593+ unsigned int set, unsigned int clear)
14594+{
14595+ struct gs_port *port = tty->driver_data;
14596+ struct gserial *gser;
14597+ int status = 0;
14598+
14599+ if (!port)
14600+ return -ENODEV;
14601+ spin_lock_irq(&port->port_lock);
14602+ gser = port->port_usb;
14603+ if (!gser) {
14604+ status = -ENODEV;
14605+ goto fail;
14606+ }
14607+
14608+ if (set & TIOCM_RI) {
14609+ if (gser->send_ring_indicator) {
14610+ gser->serial_state |= TIOCM_RI;
14611+ status = gser->send_ring_indicator(gser, 1);
14612+ }
14613+ }
14614+ if (clear & TIOCM_RI) {
14615+ if (gser->send_ring_indicator) {
14616+ gser->serial_state &= ~TIOCM_RI;
14617+ status = gser->send_ring_indicator(gser, 0);
14618+ }
14619+ }
14620+ if (set & TIOCM_CD) {
14621+ if (gser->send_carrier_detect) {
14622+ gser->serial_state |= TIOCM_CD;
14623+ status = gser->send_carrier_detect(gser, 1);
14624+ }
14625+ }
14626+ if (clear & TIOCM_CD) {
14627+ if (gser->send_carrier_detect) {
14628+ gser->serial_state &= ~TIOCM_CD;
14629+ status = gser->send_carrier_detect(gser, 0);
14630+ }
14631+ }
14632+fail:
14633+ spin_unlock_irq(&port->port_lock);
14634+ return status;
14635+}
14636 static const struct tty_operations gs_tty_ops = {
14637 .open = gs_open,
14638 .close = gs_close,
14639@@ -1080,6 +1196,8 @@ static const struct tty_operations gs_tty_ops = {
14640 .chars_in_buffer = gs_chars_in_buffer,
14641 .unthrottle = gs_unthrottle,
14642 .break_ctl = gs_break_ctl,
14643+ .tiocmget = gs_tiocmget,
14644+ .tiocmset = gs_tiocmset,
14645 };
14646
14647 /*-------------------------------------------------------------------------*/
14648@@ -1107,12 +1225,9 @@ gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
14649 tty_port_init(&port->port);
14650 spin_lock_init(&port->port_lock);
14651 init_waitqueue_head(&port->drain_wait);
14652-#ifndef CONFIG_USE_WORKQ_PUSH
14653- tasklet_init(&port->push, gs_rx_push, (unsigned long) port);
14654-#else
14655- pr_info("use workqueue push\n");
14656+
14657 INIT_WORK(&port->push, gs_rx_push);
14658-#endif
14659+
14660 INIT_LIST_HEAD(&port->read_pool);
14661 INIT_LIST_HEAD(&port->read_queue);
14662 INIT_LIST_HEAD(&port->write_pool);
14663@@ -1126,6 +1241,124 @@ out:
14664 return ret;
14665 }
14666
14667+
14668+#if defined(CONFIG_DEBUG_FS)
14669+
14670+#define BUF_SIZE 512
14671+
14672+static ssize_t debug_read_status(struct file *file, char __user *ubuf,
14673+ size_t count, loff_t *ppos)
14674+{
14675+ struct gs_port *ui_dev = file->private_data;
14676+ struct tty_struct *tty;
14677+ struct gserial *gser;
14678+ char *buf;
14679+ unsigned long flags;
14680+ int i = 0;
14681+ int ret;
14682+ int result = 0;
14683+
14684+ tty = ui_dev->port.tty;
14685+ gser = ui_dev->port_usb;
14686+
14687+ buf = kzalloc(sizeof(char) * BUF_SIZE, GFP_KERNEL);
14688+ if (!buf)
14689+ return -ENOMEM;
14690+
14691+ spin_lock_irqsave(&ui_dev->port_lock, flags);
14692+
14693+ i += scnprintf(buf + i, BUF_SIZE - i,
14694+ "nbytes_from_host: %lu\n", ui_dev->nbytes_from_host);
14695+
14696+ i += scnprintf(buf + i, BUF_SIZE - i,
14697+ "nbytes_to_tty: %lu\n", ui_dev->nbytes_to_tty);
14698+
14699+ i += scnprintf(buf + i, BUF_SIZE - i, "nbytes_with_usb_OUT_txr: %lu\n",
14700+ (ui_dev->nbytes_from_host - ui_dev->nbytes_to_tty));
14701+
14702+ i += scnprintf(buf + i, BUF_SIZE - i,
14703+ "nbytes_from_tty: %lu\n", ui_dev->nbytes_from_tty);
14704+
14705+ i += scnprintf(buf + i, BUF_SIZE - i,
14706+ "nbytes_to_host: %lu\n", ui_dev->nbytes_to_host);
14707+
14708+ i += scnprintf(buf + i, BUF_SIZE - i, "nbytes_with_usb_IN_txr: %lu\n",
14709+ (ui_dev->nbytes_from_tty - ui_dev->nbytes_to_host));
14710+
14711+ if (tty)
14712+ i += scnprintf(buf + i, BUF_SIZE - i,
14713+ "tty_flags: %lu\n", tty->flags);
14714+
14715+ if (gser->get_dtr) {
14716+ result |= (gser->get_dtr(gser) ? TIOCM_DTR : 0);
14717+ i += scnprintf(buf + i, BUF_SIZE - i,
14718+ "DTR_status: %d\n", result);
14719+ }
14720+
14721+ spin_unlock_irqrestore(&ui_dev->port_lock, flags);
14722+
14723+ ret = simple_read_from_buffer(ubuf, count, ppos, buf, i);
14724+
14725+ kfree(buf);
14726+
14727+ return ret;
14728+}
14729+
14730+static ssize_t debug_write_reset(struct file *file, const char __user *buf,
14731+ size_t count, loff_t *ppos)
14732+{
14733+ struct gs_port *ui_dev = file->private_data;
14734+ unsigned long flags;
14735+
14736+ spin_lock_irqsave(&ui_dev->port_lock, flags);
14737+ ui_dev->nbytes_from_host = ui_dev->nbytes_to_tty =
14738+ ui_dev->nbytes_from_tty = ui_dev->nbytes_to_host = 0;
14739+ spin_unlock_irqrestore(&ui_dev->port_lock, flags);
14740+
14741+ return count;
14742+}
14743+
14744+static int serial_debug_open(struct inode *inode, struct file *file)
14745+{
14746+ file->private_data = inode->i_private;
14747+ return 0;
14748+}
14749+
14750+const struct file_operations debug_rst_ops = {
14751+ .open = serial_debug_open,
14752+ .write = debug_write_reset,
14753+};
14754+
14755+const struct file_operations debug_adb_ops = {
14756+ .open = serial_debug_open,
14757+ .read = debug_read_status,
14758+};
14759+
14760+struct dentry *gs_dent;
14761+static void usb_debugfs_init(struct gs_port *ui_dev, int port_num)
14762+{
14763+ char buf[48];
14764+
14765+ snprintf(buf, 48, "usb_serial%d", port_num);
14766+ gs_dent = debugfs_create_dir(buf, 0);
14767+ if (!gs_dent || IS_ERR(gs_dent))
14768+ return;
14769+
14770+ debugfs_create_file("readstatus", 0444, gs_dent, ui_dev,
14771+ &debug_adb_ops);
14772+ debugfs_create_file("reset", S_IRUGO | S_IWUSR,
14773+ gs_dent, ui_dev, &debug_rst_ops);
14774+}
14775+
14776+static void usb_debugfs_remove(void)
14777+{
14778+ debugfs_remove_recursive(gs_dent);
14779+}
14780+#else
14781+static inline void usb_debugfs_init(struct gs_port *ui_dev, int port_num) {}
14782+static inline void usb_debugfs_remove(void) {}
14783+#endif
14784+
14785 static int gs_closed(struct gs_port *port)
14786 {
14787 int cond;
14788@@ -1138,11 +1371,7 @@ static int gs_closed(struct gs_port *port)
14789
14790 static void gserial_free_port(struct gs_port *port)
14791 {
14792-#ifndef CONFIG_USE_WORKQ_PUSH
14793- tasklet_kill(&port->push);
14794-#else
14795- flush_work(&port->push);
14796-#endif
14797+ cancel_work_sync(&port->push);
14798 /* wait for old opens to finish */
14799 wait_event(port->port.close_wait, gs_closed(port));
14800 WARN_ON(port->port_usb != NULL);
14801@@ -1281,6 +1510,10 @@ int gserial_connect(struct gserial *gser, u8 port_num)
14802 */
14803 if (port->port.count) {
14804 pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
14805+ if (gser->flags & ASYNC_LOW_LATENCY) {
14806+ pr_debug("%s: Setting to low latency", __func__);
14807+ gser->ioport->port.tty->port->low_latency = 1;
14808+ }
14809 gs_start_io(port);
14810 if (gser->connect)
14811 gser->connect(gser);
14812@@ -1318,12 +1551,6 @@ void gserial_disconnect(struct gserial *gser)
14813 if (!port)
14814 return;
14815
14816-#ifdef CONFIG_BRCM_FUSE_LOG
14817- if (port->port_num == ACM_LOGGING_PORT)
14818- if (acm_logging_cb && acm_logging_cb->stop)
14819- acm_logging_cb->stop();
14820-#endif
14821-
14822 /* tell the TTY glue not to do I/O here any more */
14823 spin_lock_irqsave(&port->port_lock, flags);
14824
14825@@ -1357,6 +1584,9 @@ void gserial_disconnect(struct gserial *gser)
14826 port->read_allocated = port->read_started =
14827 port->write_allocated = port->write_started = 0;
14828
14829+ port->nbytes_from_host = port->nbytes_to_tty =
14830+ port->nbytes_from_tty = port->nbytes_to_host = 0;
14831+
14832 spin_unlock_irqrestore(&port->port_lock, flags);
14833 }
14834 EXPORT_SYMBOL_GPL(gserial_disconnect);
14835@@ -1376,10 +1606,10 @@ static int userial_init(void)
14836
14837 gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
14838 gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
14839- gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
14840+ gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
14841+ | TTY_DRIVER_RESET_TERMIOS;
14842 gs_tty_driver->init_termios = tty_std_termios;
14843
14844-
14845 /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
14846 * MS-Windows. Otherwise, most of these flags shouldn't affect
14847 * anything unless we were to actually hook up to a serial line.
14848@@ -1393,6 +1623,12 @@ static int userial_init(void)
14849 for (i = 0; i < MAX_U_SERIAL_PORTS; i++)
14850 mutex_init(&ports[i].lock);
14851
14852+ gserial_wq = create_singlethread_workqueue("k_gserial");
14853+ if (!gserial_wq) {
14854+ status = -ENOMEM;
14855+ goto fail;
14856+ }
14857+
14858 /* export the driver ... */
14859 status = tty_register_driver(gs_tty_driver);
14860 if (status) {
14861@@ -1401,6 +1637,9 @@ static int userial_init(void)
14862 goto fail;
14863 }
14864
14865+ for (i = 0; i < MAX_U_SERIAL_PORTS; i++)
14866+ usb_debugfs_init(ports[i].port, i);
14867+
14868 pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
14869 MAX_U_SERIAL_PORTS,
14870 (MAX_U_SERIAL_PORTS == 1) ? "" : "s");
14871@@ -1408,6 +1647,8 @@ static int userial_init(void)
14872 return status;
14873 fail:
14874 put_tty_driver(gs_tty_driver);
14875+ if (gserial_wq)
14876+ destroy_workqueue(gserial_wq);
14877 gs_tty_driver = NULL;
14878 return status;
14879 }
14880@@ -1415,6 +1656,8 @@ module_init(userial_init);
14881
14882 static void userial_cleanup(void)
14883 {
14884+ usb_debugfs_remove();
14885+ destroy_workqueue(gserial_wq);
14886 tty_unregister_driver(gs_tty_driver);
14887 put_tty_driver(gs_tty_driver);
14888 gs_tty_driver = NULL;
14889diff --git a/drivers/usb/gadget/u_serial.h b/drivers/usb/gadget/u_serial.h
14890index 8c5dfae..c72257a 100644
14891--- a/drivers/usb/gadget/u_serial.h
14892+++ b/drivers/usb/gadget/u_serial.h
14893@@ -15,11 +15,7 @@
14894 #include <linux/usb/composite.h>
14895 #include <linux/usb/cdc.h>
14896
14897-#ifdef CONFIG_USB_GADGET_GG
14898-#define MAX_U_SERIAL_PORTS 6
14899-#else
14900 #define MAX_U_SERIAL_PORTS 4
14901-#endif
14902
14903 struct f_serial_opts {
14904 struct usb_function_instance func_inst;
14905@@ -47,13 +43,26 @@ struct gserial {
14906 struct usb_ep *in;
14907 struct usb_ep *out;
14908
14909+ unsigned long flags;
14910+
14911 /* REVISIT avoid this CDC-ACM support harder ... */
14912 struct usb_cdc_line_coding port_line_coding; /* 9600-8-N-1 etc */
14913+ u16 serial_state;
14914+
14915+ /* control signal callbacks*/
14916+ unsigned int (*get_dtr)(struct gserial *p);
14917+ unsigned int (*get_rts)(struct gserial *p);
14918
14919 /* notification callbacks */
14920 void (*connect)(struct gserial *p);
14921 void (*disconnect)(struct gserial *p);
14922 int (*send_break)(struct gserial *p, int duration);
14923+ unsigned int (*send_carrier_detect)(struct gserial *p, unsigned int);
14924+ unsigned int (*send_ring_indicator)(struct gserial *p, unsigned int);
14925+ int (*send_modem_ctrl_bits)(struct gserial *p, int ctrl_bits);
14926+
14927+ /* notification changes to modem */
14928+ void (*notify_modem)(void *gser, u8 portno, int ctrl_bits);
14929 };
14930
14931 /* utilities to allocate/free request and buffer */
14932@@ -68,21 +77,19 @@ void gserial_free_line(unsigned char port_line);
14933 int gserial_connect(struct gserial *, u8 port_num);
14934 void gserial_disconnect(struct gserial *);
14935
14936+/* sdio related functions */
14937+int gsdio_setup(struct usb_gadget *g, unsigned n_ports);
14938+int gsdio_connect(struct gserial *, u8 port_num);
14939+void gsdio_disconnect(struct gserial *, u8 portno);
14940+
14941+int gsmd_setup(struct usb_gadget *g, unsigned n_ports);
14942+int gsmd_connect(struct gserial *, u8 port_num);
14943+void gsmd_disconnect(struct gserial *, u8 portno);
14944+int gsmd_write(u8 portno, char *buf, unsigned int size);
14945+
14946+
14947 /* functions are bound to configurations by a config or gadget driver */
14948 int gser_bind_config(struct usb_configuration *c, u8 port_num);
14949 int obex_bind_config(struct usb_configuration *c, u8 port_num);
14950
14951-/* ACM devices */
14952-#ifdef CONFIG_BRCM_FUSE_LOG
14953-#define ACM_LOGGING_PORT 1
14954-
14955-//static struct acm_logging_callbacks *acm_logging_cb;
14956-extern struct acm_logging_callbacks *get_acm_callback_func(void);
14957-struct acm_logging_callbacks {
14958- /** Start function for role change */
14959- int (*start) (void);
14960- /** Stop Function for role change */
14961- int (*stop) (void);
14962-};
14963-#endif
14964 #endif /* __U_SERIAL_H */
14965diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
14966index afe9b9e..14f0266 100644
14967--- a/drivers/usb/gadget/udc-core.c
14968+++ b/drivers/usb/gadget/udc-core.c
14969@@ -23,9 +23,11 @@
14970 #include <linux/list.h>
14971 #include <linux/err.h>
14972 #include <linux/dma-mapping.h>
14973+#include <linux/workqueue.h>
14974
14975 #include <linux/usb/ch9.h>
14976 #include <linux/usb/gadget.h>
14977+#include <linux/usb/composite.h>
14978
14979 /**
14980 * struct usb_udc - describes one usb device controller
14981@@ -67,7 +69,7 @@ int usb_gadget_map_request(struct usb_gadget *gadget,
14982 }
14983
14984 req->num_mapped_sgs = mapped;
14985- } else {
14986+ } else if (!req->dma_pre_mapped) {
14987 req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
14988 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
14989
14990@@ -92,20 +94,34 @@ void usb_gadget_unmap_request(struct usb_gadget *gadget,
14991 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
14992
14993 req->num_mapped_sgs = 0;
14994- } else {
14995+ } else if (!req->dma_pre_mapped && req->dma != DMA_ERROR_CODE) {
14996+ /*
14997+ * If the DMA address has not been mapped by a higher layer,
14998+ * then unmap it here. Otherwise, the DMA address will be
14999+ * unmapped by the upper layer (where the request was queued).
15000+ */
15001 dma_unmap_single(&gadget->dev, req->dma, req->length,
15002- is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
15003+ is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
15004+
15005+ req->dma = DMA_ERROR_CODE;
15006 }
15007 }
15008 EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
15009
15010 /* ------------------------------------------------------------------------- */
15011
15012+static void usb_gadget_state_work(struct work_struct *work)
15013+{
15014+ struct usb_gadget *gadget = work_to_gadget(work);
15015+
15016+ sysfs_notify(&gadget->dev.kobj, NULL, "status");
15017+}
15018+
15019 void usb_gadget_set_state(struct usb_gadget *gadget,
15020 enum usb_device_state state)
15021 {
15022 gadget->state = state;
15023- sysfs_notify(&gadget->dev.kobj, NULL, "state");
15024+ schedule_work(&gadget->work);
15025 }
15026 EXPORT_SYMBOL_GPL(usb_gadget_set_state);
15027
15028@@ -192,6 +208,7 @@ int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
15029 goto err1;
15030
15031 dev_set_name(&gadget->dev, "gadget");
15032+ INIT_WORK(&gadget->work, usb_gadget_state_work);
15033 gadget->dev.parent = parent;
15034
15035 dma_set_coherent_mask(&gadget->dev, parent->coherent_dma_mask);
15036@@ -309,6 +326,7 @@ found:
15037 usb_gadget_remove_driver(udc);
15038
15039 kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
15040+ flush_work(&gadget->work);
15041 device_unregister(&udc->dev);
15042 device_unregister(&gadget->dev);
15043 }
15044@@ -335,15 +353,6 @@ static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *dri
15045 driver->unbind(udc->gadget);
15046 goto err1;
15047 }
15048- /*
15049- * HACK: The Android gadget driver disconnects the gadget
15050- * on bind and expects the gadget to stay disconnected until
15051- * it calls usb_gadget_connect when userspace is ready. Remove
15052- * the call to usb_gadget_connect bellow to avoid enabling the
15053- * pullup before userspace is ready.
15054- *
15055- * usb_gadget_connect(udc->gadget);
15056- */
15057
15058 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
15059 return 0;
15060@@ -392,8 +401,9 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
15061
15062 mutex_lock(&udc_lock);
15063 list_for_each_entry(udc, &udc_list, list) {
15064- /* For now we take the first one */
15065- if (!udc->driver)
15066+ /* Match according to usb_core_id */
15067+ if (!udc->driver && udc->gadget &&
15068+ udc->gadget->usb_core_id == driver->usb_core_id)
15069 goto found;
15070 }
15071
15072@@ -428,6 +438,37 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
15073 }
15074 EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
15075
15076+int usb_func_ep_queue(struct usb_function *func, struct usb_ep *ep,
15077+ struct usb_request *req, gfp_t gfp_flags)
15078+{
15079+ int ret;
15080+ struct usb_gadget *gadget;
15081+
15082+ if (!func || !ep || !req) {
15083+ pr_err("Invalid argument. func=%p, ep=%p, req=%p\n",
15084+ func, ep, req);
15085+ return -EINVAL;
15086+ }
15087+
15088+ pr_debug("Function %s queueing new data into ep %u\n",
15089+ func->name ? func->name : "", ep->address);
15090+
15091+ gadget = func->config->cdev->gadget;
15092+ if ((gadget->speed == USB_SPEED_SUPER) && func->func_is_suspended) {
15093+ ret = usb_func_wakeup(func);
15094+ if (ret) {
15095+ pr_err("Failed to send function wake up notification. func name:%s, ep:%u\n",
15096+ func->name ? func->name : "",
15097+ ep->address);
15098+ return ret;
15099+ }
15100+ }
15101+
15102+ ret = usb_ep_queue(ep, req, gfp_flags);
15103+ return ret;
15104+}
15105+
15106+
15107 /* ------------------------------------------------------------------------- */
15108
15109 static ssize_t usb_udc_srp_store(struct device *dev,
15110diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
15111index 05c6118..745bf1b 100644
15112--- a/include/linux/usb/gadget.h
15113+++ b/include/linux/usb/gadget.h
15114@@ -22,6 +22,7 @@
15115 #include <linux/slab.h>
15116 #include <linux/scatterlist.h>
15117 #include <linux/types.h>
15118+#include <linux/workqueue.h>
15119 #include <linux/usb/ch9.h>
15120
15121 struct usb_ep;
15122@@ -45,6 +46,11 @@ struct usb_ep;
15123 * by adding a zero length packet as needed;
15124 * @short_not_ok: When reading data, makes short packets be
15125 * treated as errors (queue stops advancing till cleanup).
15126+ * @dma_pre_mapped: Tells the USB core driver whether this request should be
15127+ * DMA-mapped before it is queued to the USB HW. When set to true, it means
15128+ * that the request has already been mapped in advance and therefore the
15129+ * USB core driver does NOT need to do DMA-mapping when the request is
15130+ * queued to the USB HW.
15131 * @complete: Function called when request completes, so this request and
15132 * its buffer may be re-used. The function will always be called with
15133 * interrupts disabled, and it must not sleep.
15134@@ -68,6 +74,7 @@ struct usb_ep;
15135 * Note that for writes (IN transfers) some data bytes may still
15136 * reside in a device-side FIFO when the request is reported as
15137 * complete.
15138+ *@udc_priv: Vendor private data in usage by the UDC.
15139 *
15140 * These are allocated/freed through the endpoint they're used with. The
15141 * hardware's driver can add extra per-request data to the memory it returns,
15142@@ -100,6 +107,7 @@ struct usb_request {
15143 unsigned no_interrupt:1;
15144 unsigned zero:1;
15145 unsigned short_not_ok:1;
15146+ unsigned dma_pre_mapped:1;
15147
15148 void (*complete)(struct usb_ep *ep,
15149 struct usb_request *req);
15150@@ -108,6 +116,7 @@ struct usb_request {
15151
15152 int status;
15153 unsigned actual;
15154+ unsigned udc_priv;
15155 };
15156
15157 /*-------------------------------------------------------------------------*/
15158@@ -127,7 +136,6 @@ struct usb_ep_ops {
15159 struct usb_request *(*alloc_request) (struct usb_ep *ep,
15160 gfp_t gfp_flags);
15161 void (*free_request) (struct usb_ep *ep, struct usb_request *req);
15162-
15163 int (*queue) (struct usb_ep *ep, struct usb_request *req,
15164 gfp_t gfp_flags);
15165 int (*dequeue) (struct usb_ep *ep, struct usb_request *req);
15166@@ -158,6 +166,8 @@ struct usb_ep_ops {
15167 * enabled and remains valid until the endpoint is disabled.
15168 * @comp_desc: In case of SuperSpeed support, this is the endpoint companion
15169 * descriptor that is used to configure the endpoint
15170+ * @endless: In case where endless transfer is being initiated, this is set
15171+ * to disable usb event interrupt for few events.
15172 *
15173 * the bus controller driver lists all the general purpose endpoints in
15174 * gadget->ep_list. the control endpoint (gadget->ep0) is not in that list,
15175@@ -176,6 +186,7 @@ struct usb_ep {
15176 u8 address;
15177 const struct usb_endpoint_descriptor *desc;
15178 const struct usb_ss_ep_comp_descriptor *comp_desc;
15179+ bool endless;
15180 };
15181
15182 /*-------------------------------------------------------------------------*/
15183@@ -460,6 +471,7 @@ struct usb_gadget_driver;
15184 struct usb_gadget_ops {
15185 int (*get_frame)(struct usb_gadget *);
15186 int (*wakeup)(struct usb_gadget *);
15187+ int (*func_wakeup)(struct usb_gadget *, int interface_id);
15188 int (*set_selfpowered) (struct usb_gadget *, int is_selfpowered);
15189 int (*vbus_session) (struct usb_gadget *, int is_active);
15190 int (*vbus_draw) (struct usb_gadget *, unsigned mA);
15191@@ -471,18 +483,11 @@ struct usb_gadget_ops {
15192 struct usb_gadget_driver *);
15193 int (*udc_stop)(struct usb_gadget *,
15194 struct usb_gadget_driver *);
15195-
15196- /* Those two are deprecated */
15197- int (*start)(struct usb_gadget_driver *,
15198- int (*bind)(struct usb_gadget *));
15199- int (*stop)(struct usb_gadget_driver *);
15200-#ifdef CONFIG_USB_PCD_SETTINGS
15201- int (*pcd_start_clean) (struct usb_gadget *, int is_start);
15202-#endif
15203 };
15204
15205 /**
15206 * struct usb_gadget - represents a usb slave device
15207+ * @work: (internal use) Workqueue to be used for sysfs_notify()
15208 * @ops: Function pointers used to access hardware-specific operations.
15209 * @ep0: Endpoint zero, used when reading or writing responses to
15210 * driver setup() requests
15211@@ -503,11 +508,18 @@ struct usb_gadget_ops {
15212 * only supports HNP on a different root port.
15213 * @b_hnp_enable: OTG device feature flag, indicating that the A-Host
15214 * enabled HNP support.
15215+ * @host_request: A flag set by user when wishes to take up host role.
15216+ * @otg_srp_reqd: OTG test mode feature to initiate SRP after the end of
15217+ * current session.
15218 * @name: Identifies the controller hardware type. Used in diagnostics
15219 * and sometimes configuration.
15220 * @dev: Driver model state for this abstract device.
15221 * @out_epnum: last used out ep number
15222 * @in_epnum: last used in ep number
15223+ * @usb_core_id: Identifies the usb core controlled by this usb_gadget.
15224+ * Used in case of more then one core operates concurrently.
15225+ * @streaming_enabled: Enable streaming mode with usb core.
15226+ * @xfer_isr_count: UI (transfer complete) interrupts count
15227 *
15228 * Gadgets have a mostly-portable "gadget driver" implementing device
15229 * functions, handling all usb configurations and interfaces. Gadget
15230@@ -528,6 +540,7 @@ struct usb_gadget_ops {
15231 * device is acting as a B-Peripheral (so is_a_peripheral is false).
15232 */
15233 struct usb_gadget {
15234+ struct work_struct work;
15235 /* readonly to gadget driver */
15236 const struct usb_gadget_ops *ops;
15237 struct usb_ep *ep0;
15238@@ -541,11 +554,20 @@ struct usb_gadget {
15239 unsigned b_hnp_enable:1;
15240 unsigned a_hnp_support:1;
15241 unsigned a_alt_hnp_support:1;
15242+ unsigned host_request:1;
15243+ unsigned otg_srp_reqd:1;
15244 const char *name;
15245 struct device dev;
15246 unsigned out_epnum;
15247 unsigned in_epnum;
15248+ bool l1_supported;
15249+ u8 usb_core_id;
15250+ bool streaming_enabled;
15251+ bool remote_wakeup;
15252+ void *private;
15253+ u32 xfer_isr_count;
15254 };
15255+#define work_to_gadget(w) (container_of((w), struct usb_gadget, work))
15256
15257 static inline void set_gadget_data(struct usb_gadget *gadget, void *data)
15258 { dev_set_drvdata(&gadget->dev, data); }
15259@@ -628,6 +650,26 @@ static inline int usb_gadget_wakeup(struct usb_gadget *gadget)
15260 }
15261
15262 /**
15263+ * usb_gadget_func_wakeup - send a function remote wakeup up notification
15264+ * to the host connected to this gadget
15265+ * @gadget: controller used to wake up the host
15266+ * @interface_id: the interface which triggered the remote wakeup event
15267+ *
15268+ * Returns zero on success. Otherwise, negative error code is returned.
15269+ */
15270+static inline int usb_gadget_func_wakeup(struct usb_gadget *gadget,
15271+ int interface_id)
15272+{
15273+ if (gadget->speed != USB_SPEED_SUPER)
15274+ return -EOPNOTSUPP;
15275+
15276+ if (!gadget->ops->func_wakeup)
15277+ return -EOPNOTSUPP;
15278+
15279+ return gadget->ops->func_wakeup(gadget, interface_id);
15280+}
15281+
15282+/**
15283 * usb_gadget_set_selfpowered - sets the device selfpowered feature.
15284 * @gadget:the device being declared as self-powered
15285 *
15286@@ -757,31 +799,6 @@ static inline int usb_gadget_disconnect(struct usb_gadget *gadget)
15287 return gadget->ops->pullup(gadget, 0);
15288 }
15289
15290-#ifdef CONFIG_USB_PCD_SETTINGS
15291-/**
15292- * usb_pcd_enable - enable pcd and initialize endps
15293- *
15294- * Returns zero on success, else negative errno.
15295- */
15296-static inline int usb_pcd_enable(struct usb_gadget *gadget)
15297-{
15298- if (!gadget->ops->pcd_start_clean)
15299- return -EOPNOTSUPP;
15300- return gadget->ops->pcd_start_clean(gadget, 1);
15301-}
15302-
15303-/**
15304- * usb_pcd_disable - disable pcd and clean up endps
15305- *
15306- * Returns zero on success, else negative errno.
15307- */
15308-static inline int usb_pcd_disable(struct usb_gadget *gadget)
15309-{
15310- if (!gadget->ops->pcd_start_clean)
15311- return -EOPNOTSUPP;
15312- return gadget->ops->pcd_start_clean(gadget, 0);
15313-}
15314-#endif
15315
15316 /*-------------------------------------------------------------------------*/
15317
15318@@ -806,6 +823,8 @@ static inline int usb_pcd_disable(struct usb_gadget *gadget)
15319 * @suspend: Invoked on USB suspend. May be called in_interrupt.
15320 * @resume: Invoked on USB resume. May be called in_interrupt.
15321 * @driver: Driver model state for this driver.
15322+ * @usb_core_id: Identifies the usb core controlled by this usb_gadget_driver.
15323+ * Used in case of more then one core operates concurrently.
15324 *
15325 * Devices are disabled till a gadget driver successfully bind()s, which
15326 * means the driver will handle setup() requests needed to enumerate (and
15327@@ -865,6 +884,8 @@ struct usb_gadget_driver {
15328
15329 /* FIXME support safe rmmod */
15330 struct device_driver driver;
15331+
15332+ u8 usb_core_id;
15333 };
15334
15335
15336@@ -955,6 +976,11 @@ int usb_gadget_get_string(struct usb_gadget_strings *table, int id, u8 *buf);
15337
15338 /* utility to simplify managing config descriptors */
15339
15340+/* Find and fill the requested descriptor into buffer */
15341+int
15342+usb_find_descriptor_fillbuf(void *, unsigned,
15343+ const struct usb_descriptor_header **, u8);
15344+
15345 /* write vector of descriptors into buffer */
15346 int usb_descriptor_fillbuf(void *, unsigned,
15347 const struct usb_descriptor_header **);
15348@@ -985,6 +1011,24 @@ void usb_free_all_descriptors(struct usb_function *f);
15349
15350 /*-------------------------------------------------------------------------*/
15351
15352+/**
15353+ * usb_func_ep_queue - queues (submits) an I/O request to a function endpoint.
15354+ * This function is similar to the usb_ep_queue function, but in addition it
15355+ * also checks whether the function is in Super Speed USB Function Suspend
15356+ * state, and if so a Function Wake notification is sent to the host
15357+ * (USB 3.0 spec, section 9.2.5.2).
15358+ * @func: the function which issues the USB I/O request.
15359+ * @ep:the endpoint associated with the request
15360+ * @req:the request being submitted
15361+ * @gfp_flags: GFP_* flags to use in case the lower level driver couldn't
15362+ * pre-allocate all necessary memory with the request.
15363+ *
15364+ */
15365+int usb_func_ep_queue(struct usb_function *func, struct usb_ep *ep,
15366+ struct usb_request *req, gfp_t gfp_flags);
15367+
15368+/*-------------------------------------------------------------------------*/
15369+
15370 /* utility to simplify map/unmap of usb_requests to/from DMA */
15371
15372 extern int usb_gadget_map_request(struct usb_gadget *gadget,