blob: 67c9a1ac73f6a20a092a05def26f1061a298c0d9 [file] [log] [blame]
Chiranjeevi Velempatia06b2232013-01-04 10:10:52 +05301/* Copyright (c) 2011-2013, Linux Foundation. All rights reserved.
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 */
12
13#include <linux/kernel.h>
14#include <linux/interrupt.h>
15#include <linux/device.h>
16#include <linux/delay.h>
17#include <linux/slab.h>
18#include <linux/termios.h>
19#include <mach/msm_smd.h>
20#include <linux/netdevice.h>
21#include <mach/bam_dmux.h>
22#include <linux/debugfs.h>
23#include <linux/bitops.h>
24#include <linux/termios.h>
25
Ofir Cohena1c2a872011-12-14 10:26:34 +020026#include <mach/usb_gadget_xport.h>
Shimrit Malichi194fe122012-07-25 13:50:41 +030027#include <linux/usb/msm_hsusb.h>
Ofir Cohena1c2a872011-12-14 10:26:34 +020028#include <mach/usb_bam.h>
29
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070030#include "u_rmnet.h"
31
32#define BAM_N_PORTS 1
Anna Perel21515162012-02-02 20:50:02 +020033#define BAM2BAM_N_PORTS 3
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070034
35static struct workqueue_struct *gbam_wq;
36static int n_bam_ports;
Ofir Cohena1c2a872011-12-14 10:26:34 +020037static int n_bam2bam_ports;
Vijayavardhan Vennapusa08c31252011-12-21 13:02:49 +053038static unsigned n_tx_req_queued;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070039static unsigned bam_ch_ids[] = { 8 };
40
Jack Phameffd4ae2011-08-03 16:49:36 -070041static const char *bam_ch_names[] = { "bam_dmux_ch_8" };
42
Vamsi Krishna84579552011-11-09 15:33:22 -080043#define BAM_PENDING_LIMIT 220
Vamsi Krishna8f24f252011-11-02 11:46:08 -070044#define BAM_MUX_TX_PKT_DROP_THRESHOLD 1000
Vamsi Krishna84579552011-11-09 15:33:22 -080045#define BAM_MUX_RX_PKT_FCTRL_EN_TSHOLD 500
46#define BAM_MUX_RX_PKT_FCTRL_DIS_TSHOLD 300
Vamsi Krishna8f24f252011-11-02 11:46:08 -070047#define BAM_MUX_RX_PKT_FLOW_CTRL_SUPPORT 1
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070048
49#define BAM_MUX_HDR 8
50
Vamsi Krishna8f24f252011-11-02 11:46:08 -070051#define BAM_MUX_RX_Q_SIZE 16
52#define BAM_MUX_TX_Q_SIZE 200
Manu Gautam15203302012-09-26 11:12:54 +053053#define BAM_MUX_RX_REQ_SIZE 2048 /* Must be 1KB aligned */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070054
Vijayavardhan Vennapusa08c31252011-12-21 13:02:49 +053055#define DL_INTR_THRESHOLD 20
56
Vamsi Krishna8f24f252011-11-02 11:46:08 -070057unsigned int bam_mux_tx_pkt_drop_thld = BAM_MUX_TX_PKT_DROP_THRESHOLD;
58module_param(bam_mux_tx_pkt_drop_thld, uint, S_IRUGO | S_IWUSR);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070059
Vamsi Krishna8f24f252011-11-02 11:46:08 -070060unsigned int bam_mux_rx_fctrl_en_thld = BAM_MUX_RX_PKT_FCTRL_EN_TSHOLD;
61module_param(bam_mux_rx_fctrl_en_thld, uint, S_IRUGO | S_IWUSR);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070062
Vamsi Krishna8f24f252011-11-02 11:46:08 -070063unsigned int bam_mux_rx_fctrl_support = BAM_MUX_RX_PKT_FLOW_CTRL_SUPPORT;
64module_param(bam_mux_rx_fctrl_support, uint, S_IRUGO | S_IWUSR);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070065
Vamsi Krishna8f24f252011-11-02 11:46:08 -070066unsigned int bam_mux_rx_fctrl_dis_thld = BAM_MUX_RX_PKT_FCTRL_DIS_TSHOLD;
67module_param(bam_mux_rx_fctrl_dis_thld, uint, S_IRUGO | S_IWUSR);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070068
Vamsi Krishna8f24f252011-11-02 11:46:08 -070069unsigned int bam_mux_tx_q_size = BAM_MUX_TX_Q_SIZE;
70module_param(bam_mux_tx_q_size, uint, S_IRUGO | S_IWUSR);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070071
Vamsi Krishna8f24f252011-11-02 11:46:08 -070072unsigned int bam_mux_rx_q_size = BAM_MUX_RX_Q_SIZE;
73module_param(bam_mux_rx_q_size, uint, S_IRUGO | S_IWUSR);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070074
Vamsi Krishna8f24f252011-11-02 11:46:08 -070075unsigned int bam_mux_rx_req_size = BAM_MUX_RX_REQ_SIZE;
76module_param(bam_mux_rx_req_size, uint, S_IRUGO | S_IWUSR);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070077
Vijayavardhan Vennapusa08c31252011-12-21 13:02:49 +053078unsigned int dl_intr_threshold = DL_INTR_THRESHOLD;
79module_param(dl_intr_threshold, uint, S_IRUGO | S_IWUSR);
80
Jack Phameffd4ae2011-08-03 16:49:36 -070081#define BAM_CH_OPENED BIT(0)
82#define BAM_CH_READY BIT(1)
Ofir Cohena1c2a872011-12-14 10:26:34 +020083
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070084struct bam_ch_info {
Jack Phameffd4ae2011-08-03 16:49:36 -070085 unsigned long flags;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070086 unsigned id;
87
88 struct list_head tx_idle;
89 struct sk_buff_head tx_skb_q;
90
91 struct list_head rx_idle;
92 struct sk_buff_head rx_skb_q;
93
94 struct gbam_port *port;
95 struct work_struct write_tobam_w;
Vijayavardhan Vennapusa929e5792011-12-12 17:34:53 +053096 struct work_struct write_tohost_w;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070097
Ofir Cohena1c2a872011-12-14 10:26:34 +020098 struct usb_request *rx_req;
99 struct usb_request *tx_req;
100
Shimrit Malichi255b5342012-08-02 21:01:43 +0300101 u32 src_pipe_idx;
102 u32 dst_pipe_idx;
Shimrit Malichidbf43d72013-03-16 03:32:27 +0200103 u8 src_connection_idx;
104 u8 dst_connection_idx;
Ofir Cohenfdecb602012-11-16 15:50:01 +0200105 enum transport_type trans;
Ofir Cohen77848d62012-12-05 13:16:10 +0200106 struct usb_bam_connect_ipa_params ipa_params;
Ofir Cohena1c2a872011-12-14 10:26:34 +0200107
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700108 /* stats */
109 unsigned int pending_with_bam;
110 unsigned int tohost_drp_cnt;
111 unsigned int tomodem_drp_cnt;
112 unsigned int tx_len;
113 unsigned int rx_len;
114 unsigned long to_modem;
115 unsigned long to_host;
116};
117
118struct gbam_port {
119 unsigned port_num;
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530120 spinlock_t port_lock_ul;
121 spinlock_t port_lock_dl;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700122
123 struct grmnet *port_usb;
Ofir Cohena1c2a872011-12-14 10:26:34 +0200124 struct grmnet *gr;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700125
126 struct bam_ch_info data_ch;
127
128 struct work_struct connect_w;
Vamsi Krishna1ad076d2011-11-10 15:03:30 -0800129 struct work_struct disconnect_w;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700130};
131
132static struct bam_portmaster {
133 struct gbam_port *port;
Jack Phameffd4ae2011-08-03 16:49:36 -0700134 struct platform_driver pdrv;
135} bam_ports[BAM_N_PORTS];
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700136
Ofir Cohena1c2a872011-12-14 10:26:34 +0200137struct gbam_port *bam2bam_ports[BAM2BAM_N_PORTS];
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700138static void gbam_start_rx(struct gbam_port *port);
Ofir Cohena1c2a872011-12-14 10:26:34 +0200139static void gbam_start_endless_rx(struct gbam_port *port);
140static void gbam_start_endless_tx(struct gbam_port *port);
Amit Blay94525352012-12-24 11:23:27 +0200141static int gbam_peer_reset_cb(void *param);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700142
143/*---------------misc functions---------------- */
144static void gbam_free_requests(struct usb_ep *ep, struct list_head *head)
145{
146 struct usb_request *req;
147
148 while (!list_empty(head)) {
149 req = list_entry(head->next, struct usb_request, list);
150 list_del(&req->list);
151 usb_ep_free_request(ep, req);
152 }
153}
154
155static int gbam_alloc_requests(struct usb_ep *ep, struct list_head *head,
156 int num,
157 void (*cb)(struct usb_ep *ep, struct usb_request *),
158 gfp_t flags)
159{
160 int i;
161 struct usb_request *req;
162
163 pr_debug("%s: ep:%p head:%p num:%d cb:%p", __func__,
164 ep, head, num, cb);
165
166 for (i = 0; i < num; i++) {
167 req = usb_ep_alloc_request(ep, flags);
168 if (!req) {
169 pr_debug("%s: req allocated:%d\n", __func__, i);
170 return list_empty(head) ? -ENOMEM : 0;
171 }
172 req->complete = cb;
173 list_add(&req->list, head);
174 }
175
176 return 0;
177}
178/*--------------------------------------------- */
179
180/*------------data_path----------------------------*/
Chiranjeevi Velempatie5105922012-01-19 12:25:26 +0530181static void gbam_write_data_tohost(struct gbam_port *port)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700182{
183 unsigned long flags;
Chiranjeevi Velempatie5105922012-01-19 12:25:26 +0530184 struct bam_ch_info *d = &port->data_ch;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700185 struct sk_buff *skb;
186 int ret;
187 struct usb_request *req;
188 struct usb_ep *ep;
189
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530190 spin_lock_irqsave(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700191 if (!port->port_usb) {
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530192 spin_unlock_irqrestore(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700193 return;
194 }
195
196 ep = port->port_usb->in;
197
198 while (!list_empty(&d->tx_idle)) {
199 skb = __skb_dequeue(&d->tx_skb_q);
200 if (!skb) {
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530201 spin_unlock_irqrestore(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700202 return;
203 }
204 req = list_first_entry(&d->tx_idle,
205 struct usb_request,
206 list);
207 req->context = skb;
208 req->buf = skb->data;
209 req->length = skb->len;
Vijayavardhan Vennapusa08c31252011-12-21 13:02:49 +0530210 n_tx_req_queued++;
211 if (n_tx_req_queued == dl_intr_threshold) {
212 req->no_interrupt = 0;
213 n_tx_req_queued = 0;
214 } else {
215 req->no_interrupt = 1;
216 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700217
218 list_del(&req->list);
219
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530220 spin_unlock(&port->port_lock_dl);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700221 ret = usb_ep_queue(ep, req, GFP_ATOMIC);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530222 spin_lock(&port->port_lock_dl);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700223 if (ret) {
Chiranjeevi Velempatia06b2232013-01-04 10:10:52 +0530224 pr_err("%s: usb epIn failed with %d\n", __func__, ret);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700225 list_add(&req->list, &d->tx_idle);
226 dev_kfree_skb_any(skb);
227 break;
228 }
229 d->to_host++;
230 }
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530231 spin_unlock_irqrestore(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700232}
233
Chiranjeevi Velempatie5105922012-01-19 12:25:26 +0530234static void gbam_write_data_tohost_w(struct work_struct *w)
235{
236 struct bam_ch_info *d;
237 struct gbam_port *port;
238
239 d = container_of(w, struct bam_ch_info, write_tohost_w);
240 port = d->port;
241
242 gbam_write_data_tohost(port);
243}
244
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700245void gbam_data_recv_cb(void *p, struct sk_buff *skb)
246{
247 struct gbam_port *port = p;
248 struct bam_ch_info *d = &port->data_ch;
249 unsigned long flags;
250
251 if (!skb)
252 return;
253
254 pr_debug("%s: p:%p#%d d:%p skb_len:%d\n", __func__,
255 port, port->port_num, d, skb->len);
256
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530257 spin_lock_irqsave(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700258 if (!port->port_usb) {
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530259 spin_unlock_irqrestore(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700260 dev_kfree_skb_any(skb);
261 return;
262 }
263
Vamsi Krishna8f24f252011-11-02 11:46:08 -0700264 if (d->tx_skb_q.qlen > bam_mux_tx_pkt_drop_thld) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700265 d->tohost_drp_cnt++;
266 if (printk_ratelimit())
267 pr_err("%s: tx pkt dropped: tx_drop_cnt:%u\n",
268 __func__, d->tohost_drp_cnt);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530269 spin_unlock_irqrestore(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700270 dev_kfree_skb_any(skb);
271 return;
272 }
273
274 __skb_queue_tail(&d->tx_skb_q, skb);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530275 spin_unlock_irqrestore(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700276
Chiranjeevi Velempatie5105922012-01-19 12:25:26 +0530277 gbam_write_data_tohost(port);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700278}
279
280void gbam_data_write_done(void *p, struct sk_buff *skb)
281{
282 struct gbam_port *port = p;
283 struct bam_ch_info *d = &port->data_ch;
284 unsigned long flags;
285
286 if (!skb)
287 return;
288
289 dev_kfree_skb_any(skb);
290
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530291 spin_lock_irqsave(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700292
293 d->pending_with_bam--;
294
295 pr_debug("%s: port:%p d:%p tom:%lu pbam:%u, pno:%d\n", __func__,
296 port, d, d->to_modem,
297 d->pending_with_bam, port->port_num);
298
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530299 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700300
Vamsi Krishna84579552011-11-09 15:33:22 -0800301 queue_work(gbam_wq, &d->write_tobam_w);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700302}
303
304static void gbam_data_write_tobam(struct work_struct *w)
305{
306 struct gbam_port *port;
307 struct bam_ch_info *d;
308 struct sk_buff *skb;
309 unsigned long flags;
310 int ret;
Vamsi Krishna84579552011-11-09 15:33:22 -0800311 int qlen;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700312
313 d = container_of(w, struct bam_ch_info, write_tobam_w);
314 port = d->port;
315
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530316 spin_lock_irqsave(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700317 if (!port->port_usb) {
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530318 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700319 return;
320 }
321
Vamsi Krishna84579552011-11-09 15:33:22 -0800322 while (d->pending_with_bam < BAM_PENDING_LIMIT) {
Vamsi Krishna2327c79152011-11-08 16:12:42 -0800323 skb = __skb_dequeue(&d->rx_skb_q);
Vamsi Krishna625c28e2011-12-16 22:34:49 -0800324 if (!skb)
325 break;
326
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700327 d->pending_with_bam++;
328 d->to_modem++;
329
330 pr_debug("%s: port:%p d:%p tom:%lu pbam:%u pno:%d\n", __func__,
331 port, d, d->to_modem, d->pending_with_bam,
332 port->port_num);
333
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530334 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700335 ret = msm_bam_dmux_write(d->id, skb);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530336 spin_lock_irqsave(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700337 if (ret) {
338 pr_debug("%s: write error:%d\n", __func__, ret);
339 d->pending_with_bam--;
340 d->to_modem--;
341 d->tomodem_drp_cnt++;
342 dev_kfree_skb_any(skb);
343 break;
344 }
345 }
Vamsi Krishna84579552011-11-09 15:33:22 -0800346
347 qlen = d->rx_skb_q.qlen;
348
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530349 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Vamsi Krishna84579552011-11-09 15:33:22 -0800350
351 if (qlen < BAM_MUX_RX_PKT_FCTRL_DIS_TSHOLD)
352 gbam_start_rx(port);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700353}
354/*-------------------------------------------------------------*/
355
356static void gbam_epin_complete(struct usb_ep *ep, struct usb_request *req)
357{
358 struct gbam_port *port = ep->driver_data;
359 struct bam_ch_info *d;
360 struct sk_buff *skb = req->context;
361 int status = req->status;
362
363 switch (status) {
364 case 0:
365 /* successful completion */
Manu Gautam06277e42013-04-01 15:07:29 +0530366 break;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700367 case -ECONNRESET:
368 case -ESHUTDOWN:
369 /* connection gone */
Manu Gautam06277e42013-04-01 15:07:29 +0530370 dev_kfree_skb_any(skb);
371 usb_ep_free_request(ep, req);
372 return;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700373 default:
374 pr_err("%s: data tx ep error %d\n",
375 __func__, status);
376 break;
377 }
378
379 dev_kfree_skb_any(skb);
380
381 if (!port)
382 return;
383
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530384 spin_lock(&port->port_lock_dl);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700385 d = &port->data_ch;
386 list_add_tail(&req->list, &d->tx_idle);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530387 spin_unlock(&port->port_lock_dl);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700388
Vijayavardhan Vennapusa929e5792011-12-12 17:34:53 +0530389 queue_work(gbam_wq, &d->write_tohost_w);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700390}
391
392static void
393gbam_epout_complete(struct usb_ep *ep, struct usb_request *req)
394{
395 struct gbam_port *port = ep->driver_data;
396 struct bam_ch_info *d = &port->data_ch;
397 struct sk_buff *skb = req->context;
398 int status = req->status;
399 int queue = 0;
400
401 switch (status) {
402 case 0:
403 skb_put(skb, req->actual);
404 queue = 1;
405 break;
406 case -ECONNRESET:
407 case -ESHUTDOWN:
408 /* cable disconnection */
409 dev_kfree_skb_any(skb);
410 req->buf = 0;
411 usb_ep_free_request(ep, req);
412 return;
413 default:
414 if (printk_ratelimit())
415 pr_err("%s: %s response error %d, %d/%d\n",
416 __func__, ep->name, status,
417 req->actual, req->length);
418 dev_kfree_skb_any(skb);
419 break;
420 }
421
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530422 spin_lock(&port->port_lock_ul);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700423 if (queue) {
424 __skb_queue_tail(&d->rx_skb_q, skb);
425 queue_work(gbam_wq, &d->write_tobam_w);
426 }
427
428 /* TODO: Handle flow control gracefully by having
429 * having call back mechanism from bam driver
430 */
Vamsi Krishna8f24f252011-11-02 11:46:08 -0700431 if (bam_mux_rx_fctrl_support &&
Vamsi Krishna84579552011-11-09 15:33:22 -0800432 d->rx_skb_q.qlen >= bam_mux_rx_fctrl_en_thld) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700433
434 list_add_tail(&req->list, &d->rx_idle);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530435 spin_unlock(&port->port_lock_ul);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700436 return;
437 }
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530438 spin_unlock(&port->port_lock_ul);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700439
Vamsi Krishna8f24f252011-11-02 11:46:08 -0700440 skb = alloc_skb(bam_mux_rx_req_size + BAM_MUX_HDR, GFP_ATOMIC);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700441 if (!skb) {
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530442 spin_lock(&port->port_lock_ul);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700443 list_add_tail(&req->list, &d->rx_idle);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530444 spin_unlock(&port->port_lock_ul);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700445 return;
446 }
447 skb_reserve(skb, BAM_MUX_HDR);
448
449 req->buf = skb->data;
Vamsi Krishna8f24f252011-11-02 11:46:08 -0700450 req->length = bam_mux_rx_req_size;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700451 req->context = skb;
452
453 status = usb_ep_queue(ep, req, GFP_ATOMIC);
454 if (status) {
455 dev_kfree_skb_any(skb);
456
457 if (printk_ratelimit())
458 pr_err("%s: data rx enqueue err %d\n",
459 __func__, status);
460
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530461 spin_lock(&port->port_lock_ul);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700462 list_add_tail(&req->list, &d->rx_idle);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530463 spin_unlock(&port->port_lock_ul);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700464 }
465}
466
Ofir Cohena1c2a872011-12-14 10:26:34 +0200467static void gbam_endless_rx_complete(struct usb_ep *ep, struct usb_request *req)
468{
469 int status = req->status;
470
471 pr_debug("%s status: %d\n", __func__, status);
472}
473
474static void gbam_endless_tx_complete(struct usb_ep *ep, struct usb_request *req)
475{
476 int status = req->status;
477
478 pr_debug("%s status: %d\n", __func__, status);
479}
480
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700481static void gbam_start_rx(struct gbam_port *port)
482{
483 struct usb_request *req;
484 struct bam_ch_info *d;
485 struct usb_ep *ep;
486 unsigned long flags;
487 int ret;
488 struct sk_buff *skb;
489
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530490 spin_lock_irqsave(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700491 if (!port->port_usb) {
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530492 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700493 return;
494 }
495
496 d = &port->data_ch;
497 ep = port->port_usb->out;
498
499 while (port->port_usb && !list_empty(&d->rx_idle)) {
Vamsi Krishna84579552011-11-09 15:33:22 -0800500
501 if (bam_mux_rx_fctrl_support &&
502 d->rx_skb_q.qlen >= bam_mux_rx_fctrl_en_thld)
503 break;
504
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700505 req = list_first_entry(&d->rx_idle, struct usb_request, list);
506
Vamsi Krishna8f24f252011-11-02 11:46:08 -0700507 skb = alloc_skb(bam_mux_rx_req_size + BAM_MUX_HDR, GFP_ATOMIC);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700508 if (!skb)
509 break;
510 skb_reserve(skb, BAM_MUX_HDR);
511
512 list_del(&req->list);
513 req->buf = skb->data;
Vamsi Krishna8f24f252011-11-02 11:46:08 -0700514 req->length = bam_mux_rx_req_size;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700515 req->context = skb;
516
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530517 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700518 ret = usb_ep_queue(ep, req, GFP_ATOMIC);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530519 spin_lock_irqsave(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700520 if (ret) {
521 dev_kfree_skb_any(skb);
522
523 if (printk_ratelimit())
Chiranjeevi Velempatia06b2232013-01-04 10:10:52 +0530524 pr_err("%s: rx queue failed %d\n",
525 __func__, ret);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700526
527 if (port->port_usb)
528 list_add(&req->list, &d->rx_idle);
529 else
530 usb_ep_free_request(ep, req);
531 break;
532 }
533 }
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530534 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700535}
536
Ofir Cohena1c2a872011-12-14 10:26:34 +0200537static void gbam_start_endless_rx(struct gbam_port *port)
538{
539 struct bam_ch_info *d = &port->data_ch;
540 int status;
541
Amit Blay94525352012-12-24 11:23:27 +0200542 if (!port->port_usb)
543 return;
544
Ofir Cohena1c2a872011-12-14 10:26:34 +0200545 status = usb_ep_queue(port->port_usb->out, d->rx_req, GFP_ATOMIC);
546 if (status)
547 pr_err("%s: error enqueuing transfer, %d\n", __func__, status);
548}
549
550static void gbam_start_endless_tx(struct gbam_port *port)
551{
552 struct bam_ch_info *d = &port->data_ch;
553 int status;
554
Amit Blay94525352012-12-24 11:23:27 +0200555 if (!port->port_usb)
556 return;
557
Ofir Cohena1c2a872011-12-14 10:26:34 +0200558 status = usb_ep_queue(port->port_usb->in, d->tx_req, GFP_ATOMIC);
559 if (status)
560 pr_err("%s: error enqueuing transfer, %d\n", __func__, status);
561}
562
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700563static void gbam_start_io(struct gbam_port *port)
564{
565 unsigned long flags;
566 struct usb_ep *ep;
567 int ret;
568 struct bam_ch_info *d;
569
570 pr_debug("%s: port:%p\n", __func__, port);
571
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530572 spin_lock_irqsave(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700573 if (!port->port_usb) {
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530574 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700575 return;
576 }
577
578 d = &port->data_ch;
579 ep = port->port_usb->out;
Vamsi Krishna8f24f252011-11-02 11:46:08 -0700580 ret = gbam_alloc_requests(ep, &d->rx_idle, bam_mux_rx_q_size,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700581 gbam_epout_complete, GFP_ATOMIC);
582 if (ret) {
583 pr_err("%s: rx req allocation failed\n", __func__);
584 return;
585 }
586
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530587 spin_unlock_irqrestore(&port->port_lock_ul, flags);
588 spin_lock_irqsave(&port->port_lock_dl, flags);
Chiranjeevi Velempati44d02982013-02-17 22:09:08 +0530589 if (!port->port_usb) {
590 gbam_free_requests(ep, &d->rx_idle);
591 spin_unlock_irqrestore(&port->port_lock_dl, flags);
592 return;
593 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700594 ep = port->port_usb->in;
Vamsi Krishna8f24f252011-11-02 11:46:08 -0700595 ret = gbam_alloc_requests(ep, &d->tx_idle, bam_mux_tx_q_size,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700596 gbam_epin_complete, GFP_ATOMIC);
597 if (ret) {
598 pr_err("%s: tx req allocation failed\n", __func__);
599 gbam_free_requests(ep, &d->rx_idle);
600 return;
601 }
602
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530603 spin_unlock_irqrestore(&port->port_lock_dl, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700604
605 /* queue out requests */
606 gbam_start_rx(port);
607}
608
Jeff Hugo1c4531c2011-08-02 14:55:37 -0600609static void gbam_notify(void *p, int event, unsigned long data)
610{
611 switch (event) {
612 case BAM_DMUX_RECEIVE:
613 gbam_data_recv_cb(p, (struct sk_buff *)(data));
614 break;
615 case BAM_DMUX_WRITE_DONE:
616 gbam_data_write_done(p, (struct sk_buff *)(data));
617 break;
618 }
619}
620
Ofir Cohena1c2a872011-12-14 10:26:34 +0200621static void gbam_free_buffers(struct gbam_port *port)
622{
623 struct sk_buff *skb;
624 unsigned long flags;
625 struct bam_ch_info *d;
626
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530627 spin_lock_irqsave(&port->port_lock_ul, flags);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800628 spin_lock(&port->port_lock_dl);
Ofir Cohena1c2a872011-12-14 10:26:34 +0200629
630 if (!port || !port->port_usb)
631 goto free_buf_out;
632
633 d = &port->data_ch;
634
635 gbam_free_requests(port->port_usb->in, &d->tx_idle);
636 gbam_free_requests(port->port_usb->out, &d->rx_idle);
637
638 while ((skb = __skb_dequeue(&d->tx_skb_q)))
639 dev_kfree_skb_any(skb);
640
641 while ((skb = __skb_dequeue(&d->rx_skb_q)))
642 dev_kfree_skb_any(skb);
643
644free_buf_out:
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800645 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530646 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Ofir Cohena1c2a872011-12-14 10:26:34 +0200647}
648
Vamsi Krishna1ad076d2011-11-10 15:03:30 -0800649static void gbam_disconnect_work(struct work_struct *w)
650{
651 struct gbam_port *port =
652 container_of(w, struct gbam_port, disconnect_w);
653 struct bam_ch_info *d = &port->data_ch;
654
655 if (!test_bit(BAM_CH_OPENED, &d->flags))
656 return;
657
658 msm_bam_dmux_close(d->id);
659 clear_bit(BAM_CH_OPENED, &d->flags);
660}
661
Ofir Cohenfdecb602012-11-16 15:50:01 +0200662static void gbam2bam_disconnect_work(struct work_struct *w)
663{
Shimrit Malichi419fdac2013-01-16 14:35:31 +0200664 struct gbam_port *port =
665 container_of(w, struct gbam_port, disconnect_w);
Ofir Cohenfdecb602012-11-16 15:50:01 +0200666 struct bam_ch_info *d = &port->data_ch;
667 int ret;
668
669 if (d->trans == USB_GADGET_XPORT_BAM2BAM_IPA) {
Shimrit Malichidbf43d72013-03-16 03:32:27 +0200670 ret = usb_bam_disconnect_ipa(&d->ipa_params);
Ofir Cohenfdecb602012-11-16 15:50:01 +0200671 if (ret)
672 pr_err("%s: usb_bam_disconnect_ipa failed: err:%d\n",
673 __func__, ret);
Shimrit Malichi085a3d22013-03-10 10:30:08 +0200674 teth_bridge_disconnect();
Ofir Cohenfdecb602012-11-16 15:50:01 +0200675 }
676}
677
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700678static void gbam_connect_work(struct work_struct *w)
679{
680 struct gbam_port *port = container_of(w, struct gbam_port, connect_w);
681 struct bam_ch_info *d = &port->data_ch;
682 int ret;
Vamsi Krishna1ad076d2011-11-10 15:03:30 -0800683 unsigned long flags;
684
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530685 spin_lock_irqsave(&port->port_lock_ul, flags);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800686 spin_lock(&port->port_lock_dl);
Vamsi Krishna1ad076d2011-11-10 15:03:30 -0800687 if (!port->port_usb) {
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800688 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530689 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Vamsi Krishna1ad076d2011-11-10 15:03:30 -0800690 return;
691 }
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800692 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530693 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700694
Jack Phameffd4ae2011-08-03 16:49:36 -0700695 if (!test_bit(BAM_CH_READY, &d->flags))
696 return;
697
Jeff Hugo1c4531c2011-08-02 14:55:37 -0600698 ret = msm_bam_dmux_open(d->id, port, gbam_notify);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700699 if (ret) {
700 pr_err("%s: unable open bam ch:%d err:%d\n",
701 __func__, d->id, ret);
702 return;
703 }
Jack Phameffd4ae2011-08-03 16:49:36 -0700704 set_bit(BAM_CH_OPENED, &d->flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700705
706 gbam_start_io(port);
707
708 pr_debug("%s: done\n", __func__);
709}
710
Ofir Cohena1c2a872011-12-14 10:26:34 +0200711static void gbam2bam_connect_work(struct work_struct *w)
Jack Phameffd4ae2011-08-03 16:49:36 -0700712{
Ofir Cohena1c2a872011-12-14 10:26:34 +0200713 struct gbam_port *port = container_of(w, struct gbam_port, connect_w);
Shimrit Malichi085a3d22013-03-10 10:30:08 +0200714 struct teth_bridge_connect_params connect_params;
Ofir Cohena1c2a872011-12-14 10:26:34 +0200715 struct bam_ch_info *d = &port->data_ch;
716 u32 sps_params;
Shimrit Malichi085a3d22013-03-10 10:30:08 +0200717 ipa_notify_cb usb_notify_cb;
718 void *priv;
Ofir Cohena1c2a872011-12-14 10:26:34 +0200719 int ret;
Jack Phameffd4ae2011-08-03 16:49:36 -0700720
Ofir Cohenfdecb602012-11-16 15:50:01 +0200721 if (d->trans == USB_GADGET_XPORT_BAM2BAM) {
Shimrit Malichidbf43d72013-03-16 03:32:27 +0200722 ret = usb_bam_connect(d->src_connection_idx, &d->src_pipe_idx);
Ofir Cohenfdecb602012-11-16 15:50:01 +0200723 if (ret) {
Shimrit Malichidbf43d72013-03-16 03:32:27 +0200724 pr_err("%s: usb_bam_connect (src) failed: err:%d\n",
725 __func__, ret);
726 return;
727 }
728 ret = usb_bam_connect(d->dst_connection_idx, &d->dst_pipe_idx);
729 if (ret) {
730 pr_err("%s: usb_bam_connect (dst) failed: err:%d\n",
Ofir Cohenfdecb602012-11-16 15:50:01 +0200731 __func__, ret);
732 return;
733 }
734 } else if (d->trans == USB_GADGET_XPORT_BAM2BAM_IPA) {
Shimrit Malichi085a3d22013-03-10 10:30:08 +0200735 ret = teth_bridge_init(&usb_notify_cb, &priv);
736 if (ret) {
737 pr_err("%s:teth_bridge_init() failed\n", __func__);
738 return;
739 }
740 d->ipa_params.notify = usb_notify_cb;
741 d->ipa_params.priv = priv;
742 d->ipa_params.ipa_ep_cfg.mode.mode = IPA_BASIC;
743
Ofir Cohen77848d62012-12-05 13:16:10 +0200744 d->ipa_params.client = IPA_CLIENT_USB_CONS;
745 d->ipa_params.dir = PEER_PERIPHERAL_TO_USB;
746 ret = usb_bam_connect_ipa(&d->ipa_params);
Ofir Cohenfdecb602012-11-16 15:50:01 +0200747 if (ret) {
748 pr_err("%s: usb_bam_connect_ipa failed: err:%d\n",
749 __func__, ret);
750 return;
751 }
752
Ofir Cohen77848d62012-12-05 13:16:10 +0200753 d->ipa_params.client = IPA_CLIENT_USB_PROD;
754 d->ipa_params.dir = USB_TO_PEER_PERIPHERAL;
Ofir Cohen77848d62012-12-05 13:16:10 +0200755 ret = usb_bam_connect_ipa(&d->ipa_params);
Ofir Cohenfdecb602012-11-16 15:50:01 +0200756 if (ret) {
757 pr_err("%s: usb_bam_connect_ipa failed: err:%d\n",
758 __func__, ret);
759 return;
760 }
Shimrit Malichi085a3d22013-03-10 10:30:08 +0200761
762 connect_params.ipa_usb_pipe_hdl = d->ipa_params.prod_clnt_hdl;
763 connect_params.usb_ipa_pipe_hdl = d->ipa_params.cons_clnt_hdl;
764 connect_params.tethering_mode = TETH_TETHERING_MODE_RMNET;
765 ret = teth_bridge_connect(&connect_params);
766 if (ret) {
767 pr_err("%s:teth_bridge_connect() failed\n", __func__);
768 return;
769 }
Ofir Cohena1c2a872011-12-14 10:26:34 +0200770 }
Jack Phameffd4ae2011-08-03 16:49:36 -0700771
Ofir Cohena1c2a872011-12-14 10:26:34 +0200772 d->rx_req = usb_ep_alloc_request(port->port_usb->out, GFP_KERNEL);
773 if (!d->rx_req)
774 return;
Jack Phameffd4ae2011-08-03 16:49:36 -0700775
Ofir Cohena1c2a872011-12-14 10:26:34 +0200776 d->rx_req->context = port;
777 d->rx_req->complete = gbam_endless_rx_complete;
778 d->rx_req->length = 0;
Ido Shayevitzd1cb16c2012-03-28 18:57:47 +0200779 sps_params = (MSM_SPS_MODE | d->src_pipe_idx |
780 MSM_VENDOR_ID) & ~MSM_IS_FINITE_TRANSFER;
Ofir Cohena1c2a872011-12-14 10:26:34 +0200781 d->rx_req->udc_priv = sps_params;
782 d->tx_req = usb_ep_alloc_request(port->port_usb->in, GFP_KERNEL);
783 if (!d->tx_req)
784 return;
Jack Phameffd4ae2011-08-03 16:49:36 -0700785
Ofir Cohena1c2a872011-12-14 10:26:34 +0200786 d->tx_req->context = port;
787 d->tx_req->complete = gbam_endless_tx_complete;
788 d->tx_req->length = 0;
Ido Shayevitzd1cb16c2012-03-28 18:57:47 +0200789 sps_params = (MSM_SPS_MODE | d->dst_pipe_idx |
790 MSM_VENDOR_ID) & ~MSM_IS_FINITE_TRANSFER;
Ofir Cohena1c2a872011-12-14 10:26:34 +0200791 d->tx_req->udc_priv = sps_params;
Jack Phameffd4ae2011-08-03 16:49:36 -0700792
Ofir Cohena1c2a872011-12-14 10:26:34 +0200793 /* queue in & out requests */
794 gbam_start_endless_rx(port);
795 gbam_start_endless_tx(port);
Jack Phameffd4ae2011-08-03 16:49:36 -0700796
Amit Blay94525352012-12-24 11:23:27 +0200797 if (d->trans == USB_GADGET_XPORT_BAM2BAM && port->port_num == 0) {
798 /* Register for peer reset callback */
Shimrit Malichidbf43d72013-03-16 03:32:27 +0200799 usb_bam_register_peer_reset_cb(gbam_peer_reset_cb, port);
Amit Blay94525352012-12-24 11:23:27 +0200800
801 ret = usb_bam_client_ready(true);
802 if (ret) {
803 pr_err("%s: usb_bam_client_ready failed: err:%d\n",
804 __func__, ret);
805 return;
806 }
807 }
808
Ofir Cohena1c2a872011-12-14 10:26:34 +0200809 pr_debug("%s: done\n", __func__);
Jack Phameffd4ae2011-08-03 16:49:36 -0700810}
811
Amit Blay94525352012-12-24 11:23:27 +0200812static int gbam_peer_reset_cb(void *param)
813{
814 struct gbam_port *port = (struct gbam_port *)param;
815 struct bam_ch_info *d;
816 struct f_rmnet *dev;
817 struct usb_gadget *gadget;
818 int ret;
819 bool reenable_eps = false;
820
821 dev = port_to_rmnet(port->gr);
822 d = &port->data_ch;
823
824 gadget = dev->cdev->gadget;
825
826 pr_debug("%s: reset by peer\n", __func__);
827
828 /* Disable the relevant EPs if currently EPs are enabled */
829 if (port->port_usb && port->port_usb->in &&
830 port->port_usb->in->driver_data) {
831 usb_ep_disable(port->port_usb->out);
832 usb_ep_disable(port->port_usb->in);
833
834 port->port_usb->in->driver_data = NULL;
835 port->port_usb->out->driver_data = NULL;
836 reenable_eps = true;
837 }
838
839 /* Disable BAM */
840 msm_hw_bam_disable(1);
841
842 /* Reset BAM */
Shimrit Malichidbf43d72013-03-16 03:32:27 +0200843 ret = usb_bam_a2_reset();
Amit Blay94525352012-12-24 11:23:27 +0200844 if (ret) {
845 pr_err("%s: BAM reset failed %d\n", __func__, ret);
846 goto reenable_eps;
847 }
848
849 /* Enable BAM */
850 msm_hw_bam_disable(0);
851
852reenable_eps:
853 /* Re-Enable the relevant EPs, if EPs were originally enabled */
854 if (reenable_eps) {
855 ret = usb_ep_enable(port->port_usb->in);
856 if (ret) {
857 pr_err("%s: usb_ep_enable failed eptype:IN ep:%p",
858 __func__, port->port_usb->in);
859 return ret;
860 }
861 port->port_usb->in->driver_data = port;
862
863 ret = usb_ep_enable(port->port_usb->out);
864 if (ret) {
865 pr_err("%s: usb_ep_enable failed eptype:OUT ep:%p",
866 __func__, port->port_usb->out);
867 port->port_usb->in->driver_data = 0;
868 return ret;
869 }
870 port->port_usb->out->driver_data = port;
871
872 gbam_start_endless_rx(port);
873 gbam_start_endless_tx(port);
874 }
875
876 /* Unregister the peer reset callback */
877 if (d->trans == USB_GADGET_XPORT_BAM2BAM && port->port_num == 0)
Shimrit Malichidbf43d72013-03-16 03:32:27 +0200878 usb_bam_register_peer_reset_cb(NULL, NULL);
Amit Blay94525352012-12-24 11:23:27 +0200879
880 return 0;
881}
882
Jack Phameffd4ae2011-08-03 16:49:36 -0700883/* BAM data channel ready, allow attempt to open */
884static int gbam_data_ch_probe(struct platform_device *pdev)
885{
886 struct gbam_port *port;
887 struct bam_ch_info *d;
888 int i;
889 unsigned long flags;
890
891 pr_debug("%s: name:%s\n", __func__, pdev->name);
892
893 for (i = 0; i < n_bam_ports; i++) {
894 port = bam_ports[i].port;
895 d = &port->data_ch;
896
897 if (!strncmp(bam_ch_names[i], pdev->name,
898 BAM_DMUX_CH_NAME_MAX_LEN)) {
899 set_bit(BAM_CH_READY, &d->flags);
900
901 /* if usb is online, try opening bam_ch */
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530902 spin_lock_irqsave(&port->port_lock_ul, flags);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800903 spin_lock(&port->port_lock_dl);
Jack Phameffd4ae2011-08-03 16:49:36 -0700904 if (port->port_usb)
905 queue_work(gbam_wq, &port->connect_w);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800906 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530907 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Jack Phameffd4ae2011-08-03 16:49:36 -0700908
909 break;
910 }
911 }
912
913 return 0;
914}
915
916/* BAM data channel went inactive, so close it */
917static int gbam_data_ch_remove(struct platform_device *pdev)
918{
919 struct gbam_port *port;
920 struct bam_ch_info *d;
921 struct usb_ep *ep_in = NULL;
922 struct usb_ep *ep_out = NULL;
923 unsigned long flags;
924 int i;
925
926 pr_debug("%s: name:%s\n", __func__, pdev->name);
927
928 for (i = 0; i < n_bam_ports; i++) {
929 if (!strncmp(bam_ch_names[i], pdev->name,
930 BAM_DMUX_CH_NAME_MAX_LEN)) {
931 port = bam_ports[i].port;
932 d = &port->data_ch;
933
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530934 spin_lock_irqsave(&port->port_lock_ul, flags);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800935 spin_lock(&port->port_lock_dl);
Jack Phameffd4ae2011-08-03 16:49:36 -0700936 if (port->port_usb) {
937 ep_in = port->port_usb->in;
938 ep_out = port->port_usb->out;
939 }
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -0800940 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530941 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Jack Phameffd4ae2011-08-03 16:49:36 -0700942
943 if (ep_in)
944 usb_ep_fifo_flush(ep_in);
945 if (ep_out)
946 usb_ep_fifo_flush(ep_out);
947
948 gbam_free_buffers(port);
949
950 msm_bam_dmux_close(d->id);
951
Vamsi Krishna7658bd12012-01-13 10:32:00 -0800952 /* bam dmux will free all pending skbs */
953 d->pending_with_bam = 0;
954
Jack Phameffd4ae2011-08-03 16:49:36 -0700955 clear_bit(BAM_CH_READY, &d->flags);
956 clear_bit(BAM_CH_OPENED, &d->flags);
957 }
958 }
959
960 return 0;
961}
962
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700963static void gbam_port_free(int portno)
964{
965 struct gbam_port *port = bam_ports[portno].port;
Jack Phameffd4ae2011-08-03 16:49:36 -0700966 struct platform_driver *pdrv = &bam_ports[portno].pdrv;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700967
Jack Phameffd4ae2011-08-03 16:49:36 -0700968 if (port) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700969 kfree(port);
Jack Phameffd4ae2011-08-03 16:49:36 -0700970 platform_driver_unregister(pdrv);
971 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700972}
973
Ofir Cohena1c2a872011-12-14 10:26:34 +0200974static void gbam2bam_port_free(int portno)
975{
976 struct gbam_port *port = bam2bam_ports[portno];
977
978 kfree(port);
979}
980
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700981static int gbam_port_alloc(int portno)
982{
983 struct gbam_port *port;
984 struct bam_ch_info *d;
Jack Phameffd4ae2011-08-03 16:49:36 -0700985 struct platform_driver *pdrv;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700986
987 port = kzalloc(sizeof(struct gbam_port), GFP_KERNEL);
988 if (!port)
989 return -ENOMEM;
990
991 port->port_num = portno;
992
993 /* port initialization */
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +0530994 spin_lock_init(&port->port_lock_ul);
995 spin_lock_init(&port->port_lock_dl);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700996 INIT_WORK(&port->connect_w, gbam_connect_work);
Vamsi Krishna1ad076d2011-11-10 15:03:30 -0800997 INIT_WORK(&port->disconnect_w, gbam_disconnect_work);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700998
999 /* data ch */
1000 d = &port->data_ch;
1001 d->port = port;
1002 INIT_LIST_HEAD(&d->tx_idle);
1003 INIT_LIST_HEAD(&d->rx_idle);
1004 INIT_WORK(&d->write_tobam_w, gbam_data_write_tobam);
Chiranjeevi Velempatie5105922012-01-19 12:25:26 +05301005 INIT_WORK(&d->write_tohost_w, gbam_write_data_tohost_w);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001006 skb_queue_head_init(&d->tx_skb_q);
1007 skb_queue_head_init(&d->rx_skb_q);
1008 d->id = bam_ch_ids[portno];
1009
1010 bam_ports[portno].port = port;
1011
Jack Phameffd4ae2011-08-03 16:49:36 -07001012 pdrv = &bam_ports[portno].pdrv;
1013 pdrv->probe = gbam_data_ch_probe;
1014 pdrv->remove = gbam_data_ch_remove;
1015 pdrv->driver.name = bam_ch_names[portno];
1016 pdrv->driver.owner = THIS_MODULE;
1017
1018 platform_driver_register(pdrv);
Ofir Cohena1c2a872011-12-14 10:26:34 +02001019 pr_debug("%s: port:%p portno:%d\n", __func__, port, portno);
1020
1021 return 0;
1022}
1023
1024static int gbam2bam_port_alloc(int portno)
1025{
1026 struct gbam_port *port;
1027 struct bam_ch_info *d;
1028
1029 port = kzalloc(sizeof(struct gbam_port), GFP_KERNEL);
1030 if (!port)
1031 return -ENOMEM;
1032
1033 port->port_num = portno;
1034
1035 /* port initialization */
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301036 spin_lock_init(&port->port_lock_ul);
1037 spin_lock_init(&port->port_lock_dl);
Ofir Cohena1c2a872011-12-14 10:26:34 +02001038
1039 INIT_WORK(&port->connect_w, gbam2bam_connect_work);
Ofir Cohenfdecb602012-11-16 15:50:01 +02001040 INIT_WORK(&port->disconnect_w, gbam2bam_disconnect_work);
Ofir Cohena1c2a872011-12-14 10:26:34 +02001041
1042 /* data ch */
1043 d = &port->data_ch;
1044 d->port = port;
1045 bam2bam_ports[portno] = port;
Jack Phameffd4ae2011-08-03 16:49:36 -07001046
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001047 pr_debug("%s: port:%p portno:%d\n", __func__, port, portno);
1048
1049 return 0;
1050}
1051
1052#if defined(CONFIG_DEBUG_FS)
1053#define DEBUG_BUF_SIZE 1024
1054static ssize_t gbam_read_stats(struct file *file, char __user *ubuf,
1055 size_t count, loff_t *ppos)
1056{
1057 struct gbam_port *port;
1058 struct bam_ch_info *d;
1059 char *buf;
1060 unsigned long flags;
1061 int ret;
1062 int i;
1063 int temp = 0;
1064
1065 buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL);
1066 if (!buf)
1067 return -ENOMEM;
1068
1069 for (i = 0; i < n_bam_ports; i++) {
1070 port = bam_ports[i].port;
1071 if (!port)
1072 continue;
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301073 spin_lock_irqsave(&port->port_lock_ul, flags);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -08001074 spin_lock(&port->port_lock_dl);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001075
1076 d = &port->data_ch;
1077
1078 temp += scnprintf(buf + temp, DEBUG_BUF_SIZE - temp,
1079 "#PORT:%d port:%p data_ch:%p#\n"
1080 "dpkts_to_usbhost: %lu\n"
1081 "dpkts_to_modem: %lu\n"
1082 "dpkts_pwith_bam: %u\n"
1083 "to_usbhost_dcnt: %u\n"
1084 "tomodem__dcnt: %u\n"
1085 "tx_buf_len: %u\n"
Vamsi Krishna84579552011-11-09 15:33:22 -08001086 "rx_buf_len: %u\n"
Jack Phameffd4ae2011-08-03 16:49:36 -07001087 "data_ch_open: %d\n"
1088 "data_ch_ready: %d\n",
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001089 i, port, &port->data_ch,
1090 d->to_host, d->to_modem,
1091 d->pending_with_bam,
1092 d->tohost_drp_cnt, d->tomodem_drp_cnt,
Vamsi Krishna84579552011-11-09 15:33:22 -08001093 d->tx_skb_q.qlen, d->rx_skb_q.qlen,
Jack Phameffd4ae2011-08-03 16:49:36 -07001094 test_bit(BAM_CH_OPENED, &d->flags),
1095 test_bit(BAM_CH_READY, &d->flags));
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001096
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -08001097 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301098 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001099 }
1100
1101 ret = simple_read_from_buffer(ubuf, count, ppos, buf, temp);
1102
1103 kfree(buf);
1104
1105 return ret;
1106}
1107
1108static ssize_t gbam_reset_stats(struct file *file, const char __user *buf,
1109 size_t count, loff_t *ppos)
1110{
1111 struct gbam_port *port;
1112 struct bam_ch_info *d;
1113 int i;
1114 unsigned long flags;
1115
1116 for (i = 0; i < n_bam_ports; i++) {
1117 port = bam_ports[i].port;
1118 if (!port)
1119 continue;
1120
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301121 spin_lock_irqsave(&port->port_lock_ul, flags);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -08001122 spin_lock(&port->port_lock_dl);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001123
1124 d = &port->data_ch;
1125
1126 d->to_host = 0;
1127 d->to_modem = 0;
1128 d->pending_with_bam = 0;
1129 d->tohost_drp_cnt = 0;
1130 d->tomodem_drp_cnt = 0;
1131
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -08001132 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301133 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001134 }
1135 return count;
1136}
1137
1138const struct file_operations gbam_stats_ops = {
1139 .read = gbam_read_stats,
1140 .write = gbam_reset_stats,
1141};
1142
1143static void gbam_debugfs_init(void)
1144{
1145 struct dentry *dent;
1146 struct dentry *dfile;
1147
1148 dent = debugfs_create_dir("usb_rmnet", 0);
1149 if (IS_ERR(dent))
1150 return;
1151
1152 /* TODO: Implement cleanup function to remove created file */
1153 dfile = debugfs_create_file("status", 0444, dent, 0, &gbam_stats_ops);
1154 if (!dfile || IS_ERR(dfile))
1155 debugfs_remove(dent);
1156}
1157#else
1158static void gam_debugfs_init(void) { }
1159#endif
1160
Ofir Cohen77848d62012-12-05 13:16:10 +02001161void gbam_disconnect(struct grmnet *gr, u8 port_num, enum transport_type trans)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001162{
1163 struct gbam_port *port;
1164 unsigned long flags;
1165 struct bam_ch_info *d;
1166
1167 pr_debug("%s: grmnet:%p port#%d\n", __func__, gr, port_num);
1168
Ofir Cohena1c2a872011-12-14 10:26:34 +02001169 if (trans == USB_GADGET_XPORT_BAM &&
1170 port_num >= n_bam_ports) {
1171 pr_err("%s: invalid bam portno#%d\n",
1172 __func__, port_num);
1173 return;
1174 }
1175
Ofir Cohenfdecb602012-11-16 15:50:01 +02001176 if ((trans == USB_GADGET_XPORT_BAM2BAM ||
1177 trans == USB_GADGET_XPORT_BAM2BAM_IPA) &&
Ofir Cohena1c2a872011-12-14 10:26:34 +02001178 port_num >= n_bam2bam_ports) {
1179 pr_err("%s: invalid bam2bam portno#%d\n",
1180 __func__, port_num);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001181 return;
1182 }
1183
1184 if (!gr) {
1185 pr_err("%s: grmnet port is null\n", __func__);
1186 return;
1187 }
Ofir Cohena1c2a872011-12-14 10:26:34 +02001188 if (trans == USB_GADGET_XPORT_BAM)
1189 port = bam_ports[port_num].port;
1190 else
1191 port = bam2bam_ports[port_num];
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001192
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001193 d = &port->data_ch;
Ofir Cohena1c2a872011-12-14 10:26:34 +02001194 port->gr = gr;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001195
Ido Shayevitzeb8d8312012-09-10 11:13:11 +03001196 if (trans == USB_GADGET_XPORT_BAM)
Ofir Cohena1c2a872011-12-14 10:26:34 +02001197 gbam_free_buffers(port);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001198
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301199 spin_lock_irqsave(&port->port_lock_ul, flags);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -08001200 spin_lock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301201 port->port_usb = 0;
Vijayavardhan Vennapusa08c31252011-12-21 13:02:49 +05301202 n_tx_req_queued = 0;
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -08001203 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301204 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001205
Ido Shayevitzeb8d8312012-09-10 11:13:11 +03001206 /* disable endpoints */
1207 usb_ep_disable(gr->out);
1208 usb_ep_disable(gr->in);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001209
Ido Shayevitzeb8d8312012-09-10 11:13:11 +03001210 gr->in->driver_data = NULL;
1211 gr->out->driver_data = NULL;
1212
Ofir Cohenfdecb602012-11-16 15:50:01 +02001213 if (trans == USB_GADGET_XPORT_BAM ||
1214 trans == USB_GADGET_XPORT_BAM2BAM_IPA)
Ido Shayevitzeb8d8312012-09-10 11:13:11 +03001215 queue_work(gbam_wq, &port->disconnect_w);
Amit Blay94525352012-12-24 11:23:27 +02001216 else if (trans == USB_GADGET_XPORT_BAM2BAM) {
1217 if (port_num == 0) {
1218 if (usb_bam_client_ready(false)) {
1219 pr_err("%s: usb_bam_client_ready failed\n",
1220 __func__);
1221 }
1222 }
1223 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001224}
1225
Ofir Cohena1c2a872011-12-14 10:26:34 +02001226int gbam_connect(struct grmnet *gr, u8 port_num,
Shimrit Malichidbf43d72013-03-16 03:32:27 +02001227 enum transport_type trans, u8 src_connection_idx,
1228 u8 dst_connection_idx)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001229{
1230 struct gbam_port *port;
1231 struct bam_ch_info *d;
1232 int ret;
1233 unsigned long flags;
1234
1235 pr_debug("%s: grmnet:%p port#%d\n", __func__, gr, port_num);
1236
Ofir Cohena1c2a872011-12-14 10:26:34 +02001237 if (trans == USB_GADGET_XPORT_BAM && port_num >= n_bam_ports) {
1238 pr_err("%s: invalid portno#%d\n", __func__, port_num);
1239 return -ENODEV;
1240 }
1241
Ofir Cohenfdecb602012-11-16 15:50:01 +02001242 if ((trans == USB_GADGET_XPORT_BAM2BAM ||
1243 trans == USB_GADGET_XPORT_BAM2BAM_IPA)
1244 && port_num >= n_bam2bam_ports) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001245 pr_err("%s: invalid portno#%d\n", __func__, port_num);
1246 return -ENODEV;
1247 }
1248
1249 if (!gr) {
1250 pr_err("%s: grmnet port is null\n", __func__);
1251 return -ENODEV;
1252 }
1253
Ofir Cohena1c2a872011-12-14 10:26:34 +02001254 if (trans == USB_GADGET_XPORT_BAM)
1255 port = bam_ports[port_num].port;
1256 else
1257 port = bam2bam_ports[port_num];
1258
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001259 d = &port->data_ch;
1260
Ido Shayevitzeb8d8312012-09-10 11:13:11 +03001261 ret = usb_ep_enable(gr->in);
1262 if (ret) {
1263 pr_err("%s: usb_ep_enable failed eptype:IN ep:%p",
1264 __func__, gr->in);
1265 return ret;
1266 }
1267 gr->in->driver_data = port;
Ofir Cohen4da266f2012-01-03 10:19:29 +02001268
Ido Shayevitzeb8d8312012-09-10 11:13:11 +03001269 ret = usb_ep_enable(gr->out);
1270 if (ret) {
1271 pr_err("%s: usb_ep_enable failed eptype:OUT ep:%p",
1272 __func__, gr->out);
1273 gr->in->driver_data = 0;
1274 return ret;
1275 }
1276 gr->out->driver_data = port;
Ofir Cohen4da266f2012-01-03 10:19:29 +02001277
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301278 spin_lock_irqsave(&port->port_lock_ul, flags);
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -08001279 spin_lock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301280 port->port_usb = gr;
Ofir Cohen4da266f2012-01-03 10:19:29 +02001281
Ido Shayevitzeb8d8312012-09-10 11:13:11 +03001282 if (trans == USB_GADGET_XPORT_BAM) {
Ofir Cohena1c2a872011-12-14 10:26:34 +02001283 d->to_host = 0;
1284 d->to_modem = 0;
1285 d->pending_with_bam = 0;
1286 d->tohost_drp_cnt = 0;
1287 d->tomodem_drp_cnt = 0;
Ido Shayevitzeb8d8312012-09-10 11:13:11 +03001288 }
1289
Jeff Ohlstein6f8c5fc2012-01-17 13:08:39 -08001290 spin_unlock(&port->port_lock_dl);
Vijayavardhan Vennapusaa8808532012-01-09 15:24:02 +05301291 spin_unlock_irqrestore(&port->port_lock_ul, flags);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001292
Ofir Cohen4da266f2012-01-03 10:19:29 +02001293 if (trans == USB_GADGET_XPORT_BAM2BAM) {
1294 port->gr = gr;
Shimrit Malichidbf43d72013-03-16 03:32:27 +02001295 d->src_connection_idx = src_connection_idx;
1296 d->dst_connection_idx = dst_connection_idx;
Ofir Cohenfdecb602012-11-16 15:50:01 +02001297 } else if (trans == USB_GADGET_XPORT_BAM2BAM_IPA) {
Ofir Cohenfdecb602012-11-16 15:50:01 +02001298 port->gr = gr;
Ofir Cohen77848d62012-12-05 13:16:10 +02001299 d->ipa_params.src_pipe = &(d->src_pipe_idx);
1300 d->ipa_params.dst_pipe = &(d->dst_pipe_idx);
Shimrit Malichidbf43d72013-03-16 03:32:27 +02001301 d->ipa_params.src_idx = src_connection_idx;
1302 d->ipa_params.dst_idx = dst_connection_idx;
Ofir Cohen4da266f2012-01-03 10:19:29 +02001303 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001304
Ofir Cohenfdecb602012-11-16 15:50:01 +02001305 d->trans = trans;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001306 queue_work(gbam_wq, &port->connect_w);
1307
1308 return 0;
1309}
1310
Ofir Cohena1c2a872011-12-14 10:26:34 +02001311int gbam_setup(unsigned int no_bam_port, unsigned int no_bam2bam_port)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001312{
1313 int i;
1314 int ret;
1315
Ofir Cohena1c2a872011-12-14 10:26:34 +02001316 pr_debug("%s: requested BAM ports:%d and BAM2BAM ports:%d\n",
1317 __func__, no_bam_port, no_bam2bam_port);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001318
Ofir Cohena1c2a872011-12-14 10:26:34 +02001319 if ((!no_bam_port && !no_bam2bam_port) || no_bam_port > BAM_N_PORTS
1320 || no_bam2bam_port > BAM2BAM_N_PORTS) {
1321 pr_err("%s: Invalid num of ports count:%d,%d\n",
1322 __func__, no_bam_port, no_bam2bam_port);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001323 return -EINVAL;
1324 }
1325
1326 gbam_wq = alloc_workqueue("k_gbam", WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
1327 if (!gbam_wq) {
1328 pr_err("%s: Unable to create workqueue gbam_wq\n",
1329 __func__);
1330 return -ENOMEM;
1331 }
1332
Ofir Cohena1c2a872011-12-14 10:26:34 +02001333 for (i = 0; i < no_bam_port; i++) {
Manu Gautamd59b5d32011-09-09 14:47:08 +05301334 n_bam_ports++;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001335 ret = gbam_port_alloc(i);
1336 if (ret) {
Manu Gautamd59b5d32011-09-09 14:47:08 +05301337 n_bam_ports--;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001338 pr_err("%s: Unable to alloc port:%d\n", __func__, i);
1339 goto free_bam_ports;
1340 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001341 }
1342
Ofir Cohena1c2a872011-12-14 10:26:34 +02001343 for (i = 0; i < no_bam2bam_port; i++) {
1344 n_bam2bam_ports++;
1345 ret = gbam2bam_port_alloc(i);
1346 if (ret) {
1347 n_bam2bam_ports--;
1348 pr_err("%s: Unable to alloc port:%d\n", __func__, i);
1349 goto free_bam_ports;
1350 }
1351 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001352 gbam_debugfs_init();
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001353 return 0;
Ofir Cohena1c2a872011-12-14 10:26:34 +02001354
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001355free_bam_ports:
1356 for (i = 0; i < n_bam_ports; i++)
1357 gbam_port_free(i);
Ofir Cohena1c2a872011-12-14 10:26:34 +02001358 for (i = 0; i < n_bam2bam_ports; i++)
1359 gbam2bam_port_free(i);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001360 destroy_workqueue(gbam_wq);
1361
1362 return ret;
1363}
Amit Blaye5bb35e2012-05-08 20:38:20 +03001364
1365static int gbam_wake_cb(void *param)
1366{
1367 struct gbam_port *port = (struct gbam_port *)param;
1368 struct bam_ch_info *d;
1369 struct f_rmnet *dev;
1370
1371 dev = port_to_rmnet(port->gr);
1372 d = &port->data_ch;
1373
1374 pr_debug("%s: woken up by peer\n", __func__);
1375
1376 return usb_gadget_wakeup(dev->cdev->gadget);
1377}
1378
1379void gbam_suspend(struct grmnet *gr, u8 port_num, enum transport_type trans)
1380{
1381 struct gbam_port *port;
1382 struct bam_ch_info *d;
1383
Ofir Cohenfdecb602012-11-16 15:50:01 +02001384 if (trans != USB_GADGET_XPORT_BAM2BAM &&
1385 trans != USB_GADGET_XPORT_BAM2BAM_IPA)
Amit Blaye5bb35e2012-05-08 20:38:20 +03001386 return;
1387
1388 port = bam2bam_ports[port_num];
1389 d = &port->data_ch;
1390
1391 pr_debug("%s: suspended port %d\n", __func__, port_num);
1392
Shimrit Malichidbf43d72013-03-16 03:32:27 +02001393 usb_bam_register_wake_cb(d->dst_connection_idx, gbam_wake_cb, port);
Amit Blaye5bb35e2012-05-08 20:38:20 +03001394}
1395
1396void gbam_resume(struct grmnet *gr, u8 port_num, enum transport_type trans)
1397{
1398 struct gbam_port *port;
1399 struct bam_ch_info *d;
1400
Ofir Cohenfdecb602012-11-16 15:50:01 +02001401 if (trans != USB_GADGET_XPORT_BAM2BAM &&
1402 trans != USB_GADGET_XPORT_BAM2BAM_IPA)
Amit Blaye5bb35e2012-05-08 20:38:20 +03001403 return;
1404
1405 port = bam2bam_ports[port_num];
1406 d = &port->data_ch;
1407
1408 pr_debug("%s: resumed port %d\n", __func__, port_num);
1409
Shimrit Malichidbf43d72013-03-16 03:32:27 +02001410 usb_bam_register_wake_cb(d->dst_connection_idx, NULL, NULL);
Amit Blaye5bb35e2012-05-08 20:38:20 +03001411}