static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct f_gser *gser = func_to_gser(f);
struct usb_composite_dev *cdev = f->config->cdev;
int rc = 0;
/* we know alt == 0, so this is an activation or a reset */
#ifdef CONFIG_MODEM_SUPPORT
if (gser->notify->driver_data) {
DBG(cdev, "reset generic ctl ttyGS%d\n", gser->port_num);
usb_ep_disable(gser->notify);
}
if (!gser->notify->desc) {
if (config_ep_by_speed(cdev->gadget, f, gser->notify)) {
gser->notify->desc = NULL;
return -EINVAL;
}
}
rc = usb_ep_enable(gser->notify);
if (rc) {
ERROR(cdev, "can't enable %s, result %d\n",
gser->notify->name, rc);
return rc;
}
gser->notify->driver_data = gser;
#endif
if (gser->port.in->driver_data) {
DBG(cdev, "reset generic data ttyGS%d\n", gser->port_num);
gport_disconnect(gser);
}
if (!gser->port.in->desc || !gser->port.out->desc) {
DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
if (config_ep_by_speed(cdev->gadget, f, gser->port.in) ||
config_ep_by_speed(cdev->gadget, f, gser->port.out)) {
gser->port.in->desc = NULL;
gser->port.out->desc = NULL;
return -EINVAL;
}
}
#ifdef FEATURE_PANTECH_MODEM_REOPEN_DELAY
schedule_delayed_work(&gser->connect_work, msecs_to_jiffies(50));
#else
gport_connect(gser);
#endif
gser->online = 1;
#ifdef CONFIG_ANDROID_PANTECH_USB_MANAGER
usb_interface_enum_cb(ACM_TYPE_FLAG);
#endif
return rc;
}
static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct f_gser *gser = func_to_gser(f);
struct usb_composite_dev *cdev = f->config->cdev;
int rc = 0;
/* we know alt == 0, so this is an activation or a reset */
#ifdef CONFIG_MODEM_SUPPORT
if (gser->notify->driver_data) {
DBG(cdev, "reset generic ctl ttyGS%d\n", gser->port_num);
usb_ep_disable(gser->notify);
}
if (!gser->notify->desc) {
if (config_ep_by_speed(cdev->gadget, f, gser->notify)) {
gser->notify->desc = NULL;
return -EINVAL;
}
}
rc = usb_ep_enable(gser->notify);
if (rc) {
ERROR(cdev, "can't enable %s, result %d\n",
gser->notify->name, rc);
return rc;
}
gser->notify->driver_data = gser;
#endif
if (gser->port.in->driver_data) {
DBG(cdev, "reset generic data ttyGS%d\n", gser->port_num);
gport_disconnect(gser);
}
if (!gser->port.in->desc || !gser->port.out->desc) {
DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
if (config_ep_by_speed(cdev->gadget, f, gser->port.in) ||
config_ep_by_speed(cdev->gadget, f, gser->port.out)) {
gser->port.in->desc = NULL;
gser->port.out->desc = NULL;
return -EINVAL;
}
}
gport_connect(gser);
gser->online = 1;
#if defined(CONFIG_USB_AT)
gserial_ports[gser->port_num].enable = gser->online;
#endif
return rc;
}
static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct usb_composite_dev *cdev = f->config->cdev;
struct f_hidg *hidg = func_to_hidg(f);
int status = 0;
VDBG(cdev, "hidg_set_alt intf:%d alt:%d\n", intf, alt);
if (hidg->in_ep != NULL) {
/* restart endpoint */
if (hidg->in_ep->driver_data != NULL)
usb_ep_disable(hidg->in_ep);
status = config_ep_by_speed(f->config->cdev->gadget, f,
hidg->in_ep);
if (status) {
ERROR(cdev, "config_ep_by_speed FAILED!\n");
goto fail;
}
status = usb_ep_enable(hidg->in_ep);
if (status < 0) {
ERROR(cdev, "Enable endpoint FAILED!\n");
goto fail;
}
hidg->in_ep->driver_data = hidg;
}
fail:
return status;
}
static int eth_stop(struct net_device *net)
{
struct eth_dev *dev = netdev_priv(net);
unsigned long flags;
VDBG(dev, "%s\n", __func__);
netif_stop_queue(net);
DBG(dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
dev->net->stats.rx_packets, dev->net->stats.tx_packets,
dev->net->stats.rx_errors, dev->net->stats.tx_errors
);
spin_lock_irqsave(&dev->lock, flags);
if (dev->port_usb) {
struct gether *link = dev->port_usb;
const struct usb_endpoint_descriptor *in;
const struct usb_endpoint_descriptor *out;
if (link->close)
link->close(link);
in = link->in_ep->desc;
out = link->out_ep->desc;
usb_ep_disable(link->in_ep);
usb_ep_disable(link->out_ep);
if (netif_carrier_ok(net)) {
if (config_ep_by_speed(dev->gadget, &link->func,
link->in_ep) ||
config_ep_by_speed(dev->gadget, &link->func,
link->out_ep)) {
link->in_ep->desc = NULL;
link->out_ep->desc = NULL;
return -EINVAL;
}
DBG(dev, "host still using in/out endpoints\n");
link->in_ep->desc = in;
link->out_ep->desc = out;
usb_ep_enable(link->in_ep);
usb_ep_enable(link->out_ep);
}
}
spin_unlock_irqrestore(&dev->lock, flags);
return 0;
}
static int acc_function_set_alt(struct usb_function *f,
unsigned intf, unsigned alt)
{
struct acc_dev *dev = func_to_dev(f);
struct usb_composite_dev *cdev = f->config->cdev;
int ret;
DBG(cdev, "acc_function_set_alt intf: %d alt: %d\n", intf, alt);
ret = config_ep_by_speed(cdev->gadget, f, dev->ep_in);
if (ret) {
dev->ep_in->desc = NULL;
ERROR(cdev, "config_ep_by_speed failes for ep %s, result %d\n",
dev->ep_in->name, ret);
return ret;
}
ret = usb_ep_enable(dev->ep_in);
if (ret) {
ERROR(cdev, "failed to enable ep %s, result %d\n",
dev->ep_in->name, ret);
return ret;
}
ret = config_ep_by_speed(cdev->gadget, f, dev->ep_out);
if (ret) {
dev->ep_out->desc = NULL;
ERROR(cdev, "config_ep_by_speed failes for ep %s, result %d\n",
dev->ep_out->name, ret);
usb_ep_disable(dev->ep_in);
return ret;
}
ret = usb_ep_enable(dev->ep_out);
if (ret) {
ERROR(cdev, "failed to enable ep %s, result %d\n",
dev->ep_out->name, ret);
usb_ep_disable(dev->ep_in);
return ret;
}
dev->online = 1;
/* readers may be blocked waiting for us to go online */
wake_up(&dev->read_wq);
return 0;
}
static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct f_acm *acm = func_to_acm(f);
struct usb_composite_dev *cdev = f->config->cdev;
/* we know alt == 0, so this is an activation or a reset */
if (intf == acm->ctrl_id) {
if (acm->notify->driver_data) {
VDBG(cdev, "reset acm control interface %d\n", intf);
usb_ep_disable(acm->notify);
}
if (!acm->notify->desc)
if (config_ep_by_speed(cdev->gadget, f, acm->notify))
return -EINVAL;
usb_ep_enable(acm->notify);
acm->notify->driver_data = acm;
} else if (intf == acm->data_id) {
if (acm->port.in->driver_data) {
DBG(cdev, "reset acm ttyGS%d\n", acm->port_num);
gserial_disconnect(&acm->port);
}
if (!acm->port.in->desc || !acm->port.out->desc) {
DBG(cdev, "activate acm ttyGS%d\n", acm->port_num);
if (config_ep_by_speed(cdev->gadget, f,
acm->port.in) ||
config_ep_by_speed(cdev->gadget, f,
acm->port.out)) {
acm->port.in->desc = NULL;
acm->port.out->desc = NULL;
return -EINVAL;
}
}
gserial_connect(&acm->port, acm->port_num);
} else
return -EINVAL;
return 0;
}
static int dtf_function_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct dtf_dev *dev = func_to_dtf(f);
struct usb_composite_dev *cdev = f->config->cdev;
int ret;
int set_alt_end = 0;
int speed_check = 0;
_dbgmsg("dtf_function_set_alt(intf=%d,alt=%d)\n", intf, alt);
if( dev->pg.mCtrl_id == intf ) {
_dbgmsg_gadget( "usb_ep_enable(%s)\n", dev->pg.ep_intr->name );
ret = config_ep_by_speed(cdev->gadget, f, dev->pg.ep_intr);
if (ret) {
dev->pg.ep_intr->desc = NULL;
_dbgmsg("config_ep_by_speed failes for ep %s, result %d\n",
dev->pg.ep_intr->name, ret);
return ret;
}
ret = usb_ep_enable(dev->pg.ep_intr);
if( ret ) {
_dbgmsg( "usb_ep_enable error pg1 ep_intr ret = %d\n", ret );
return ret;
}
dev->mCtrl_ep_enbl = 1;
} else if( dev->pg.mData_id == intf ) {
_dbgmsg_gadget( "usb_ep_enable(%s)\n", dev->pg.ep_in->name );
ret = config_ep_by_speed(cdev->gadget, f, dev->pg.ep_in);
if (ret) {
dev->pg.ep_in->desc = NULL;
_dbgmsg("config_ep_by_speed failes for ep %s, result %d\n",
dev->pg.ep_in->name, ret);
return ret;
}
ret = usb_ep_enable(dev->pg.ep_intr);
if( ret ) {
_dbgmsg( "usb_ep_enable error pg1 ep_in ret = %d\n", ret );
return ret;
}
_dbgmsg_gadget( "usb_ep_enable(%s)\n", dev->pg.ep_out->name );
ret = config_ep_by_speed(cdev->gadget, f, dev->pg.ep_out);
if (ret) {
dev->pg.ep_out->desc = NULL;
_dbgmsg("config_ep_by_speed failes for ep %s, result %d\n",
dev->pg.ep_intr->name, ret);
return ret;
}
ret = usb_ep_enable(dev->pg.ep_out);
if( ret ) {
_dbgmsg( "usb_ep_enable error pg1 ep_out ret = %d\n", ret );
usb_ep_disable(dev->pg.ep_in);
return ret;
}
dev->pg.mReq_out->length = 512;
usb_ep_queue( dev->pg.ep_out, dev->pg.mReq_out, GFP_ATOMIC );
dev->mData_ep_enbl = 1;
} else {
_dbgmsg( "unknown interface number\n" );
}
set_alt_end = (
(dev->mCtrl_ep_enbl) & (dev->mData_ep_enbl) );
speed_check = (dev->cdev->gadget->speed == USB_SPEED_HIGH)?(1):(0);
if (set_alt_end == 1)
{
dtf_if_out_set_alt( speed_check );
}
return 0;
}
static int
uvc_function_set_alt(struct usb_function *f, unsigned interface, unsigned alt)
{
struct uvc_device *uvc = to_uvc(f);
struct v4l2_event v4l2_event;
struct uvc_event *uvc_event = (void *)&v4l2_event.u.data;
int ret;
INFO(f->config->cdev, "uvc_function_set_alt(%u, %u)\n", interface, alt);
if (interface == uvc->control_intf) {
if (alt)
return -EINVAL;
if (uvc->state == UVC_STATE_DISCONNECTED) {
memset(&v4l2_event, 0, sizeof(v4l2_event));
v4l2_event.type = UVC_EVENT_CONNECT;
uvc_event->speed = f->config->cdev->gadget->speed;
v4l2_event_queue(uvc->vdev, &v4l2_event);
uvc->state = UVC_STATE_CONNECTED;
}
return 0;
}
if (interface != uvc->streaming_intf)
return -EINVAL;
/* TODO
if (usb_endpoint_xfer_bulk(&uvc->desc.vs_ep))
return alt ? -EINVAL : 0;
*/
switch (alt) {
case 0:
if (uvc->state != UVC_STATE_STREAMING)
return 0;
if (uvc->video.ep)
usb_ep_disable(uvc->video.ep);
memset(&v4l2_event, 0, sizeof(v4l2_event));
v4l2_event.type = UVC_EVENT_STREAMOFF;
v4l2_event_queue(uvc->vdev, &v4l2_event);
uvc->state = UVC_STATE_CONNECTED;
return 0;
case 1:
if (uvc->state != UVC_STATE_CONNECTED)
return 0;
if (uvc->video.ep) {
ret = config_ep_by_speed(f->config->cdev->gadget,
&(uvc->func), uvc->video.ep);
if (ret)
return ret;
usb_ep_enable(uvc->video.ep);
}
memset(&v4l2_event, 0, sizeof(v4l2_event));
v4l2_event.type = UVC_EVENT_STREAMON;
v4l2_event_queue(uvc->vdev, &v4l2_event);
return USB_GADGET_DELAYED_STATUS;
default:
return -EINVAL;
}
}
/*void modem_flow_control(struct work_struct *work) {
modem_dtr_set(!!setdtr);
modem_dtr_query(&data_connect, 1);
}
void dtr_status_query(struct work_struct *work) {
modem_dtr_query(&data_connect, 1);
}
*/
static void do_activate(struct work_struct *data) {
struct rawbulk_function *fn = container_of(data, struct rawbulk_function,
activator);
int rc;
struct usb_function *functionp = &(fn->function);
printk("%s usb state %s \n", __func__, (fn->activated?"connect":"disconnect"));
if (fn->activated) { /* enumerated */
/* enabled endpoints */
rc = config_ep_by_speed(fn->cdev->gadget, functionp, fn->bulk_out);
if (rc < 0) {
printk(KERN_ERR "failed to config speed rawbulk %s %d\n",
fn->bulk_out->name, rc);
return;
}
rc = usb_ep_enable(fn->bulk_out);
if (rc < 0) {
printk(KERN_ERR "failed to enable rawbulk %s %d\n",
fn->bulk_out->name, rc);
return;
}
rc = config_ep_by_speed(fn->cdev->gadget, functionp, fn->bulk_in);
if (rc < 0) {
printk(KERN_ERR "failed to config speed rawbulk %s %d\n",
fn->bulk_in->name, rc);
return;
}
rc = usb_ep_enable(fn->bulk_in);
if (rc < 0) {
printk(KERN_ERR "failed to enable rawbulk %s %d\n",
fn->bulk_in->name, rc);
usb_ep_disable(fn->bulk_out);
return;
}
/* start rawbulk if enabled */
if (rawbulk_check_enable(fn)) {
wake_lock(&fn->keep_awake);
rc = rawbulk_start_transactions(fn->transfer_id, fn->nups,
fn->ndowns, fn->upsz, fn->downsz);
if (rc < 0)
//rawbulk_disable_function(fn);
printk(KERN_ERR "%s: failed to bypass, channel id = %d\n", __func__, fn->transfer_id);
}
/* start tty io */
rc = rawbulk_tty_alloc_request(fn);
if (rc < 0)
return;
if (!rawbulk_check_enable(fn))
rawbulk_tty_start_io(fn);
} else { /* disconnect */
if (rawbulk_check_enable(fn)) {
if (fn->transfer_id == RAWBULK_TID_MODEM) {
/* this in interrupt, but DTR need be set firstly then clear it
* */
modem_dtr_set(1, 1);
modem_dtr_set(0, 1);
modem_dtr_set(1, 1);
modem_dcd_state();
}
rawbulk_stop_transactions(fn->transfer_id);
/* keep the enable state, so we can enable again in next time */
//set_enable_state(fn, 0);
wake_unlock(&fn->keep_awake);
} else
rawbulk_tty_stop_io(fn);
rawbulk_tty_free_request(fn);
usb_ep_disable(fn->bulk_out);
usb_ep_disable(fn->bulk_in);
fn->bulk_out->driver_data = NULL;
fn->bulk_in->driver_data = NULL;
}
}
static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct f_rndis *rndis = func_to_rndis(f);
struct usb_composite_dev *cdev = f->config->cdev;
/* we know alt == 0 */
if (intf == rndis->ctrl_id) {
if (rndis->notify->driver_data) {
VDBG(cdev, "reset rndis control %d\n", intf);
usb_ep_disable(rndis->notify);
}
if (!rndis->notify->desc) {
VDBG(cdev, "init rndis ctrl %d\n", intf);
if (config_ep_by_speed(cdev->gadget, f, rndis->notify))
goto fail;
}
usb_ep_enable(rndis->notify);
rndis->notify->driver_data = rndis;
} else if (intf == rndis->data_id) {
struct net_device *net;
rndis->port.rx_triggered = false;
if (rndis->port.in_ep->driver_data) {
DBG(cdev, "reset rndis\n");
gether_disconnect(&rndis->port);
}
if (!rndis->port.in_ep->desc || !rndis->port.out_ep->desc) {
DBG(cdev, "init rndis\n");
if (config_ep_by_speed(cdev->gadget, f,
rndis->port.in_ep) ||
config_ep_by_speed(cdev->gadget, f,
rndis->port.out_ep)) {
rndis->port.in_ep->desc = NULL;
rndis->port.out_ep->desc = NULL;
goto fail;
}
}
/* Avoid ZLPs; they can be troublesome. */
rndis->port.is_zlp_ok = false;
/* RNDIS should be in the "RNDIS uninitialized" state,
* either never activated or after rndis_uninit().
*
* We don't want data to flow here until a nonzero packet
* filter is set, at which point it enters "RNDIS data
* initialized" state ... but we do want the endpoints
* to be activated. It's a strange little state.
*
* REVISIT the RNDIS gadget code has done this wrong for a
* very long time. We need another call to the link layer
* code -- gether_updown(...bool) maybe -- to do it right.
*/
rndis->port.cdc_filter = 0;
DBG(cdev, "RNDIS RX/TX early activation ...\n");
gether_enable_sg(&rndis->port, true);
net = gether_connect(&rndis->port);
if (IS_ERR(net))
return PTR_ERR(net);
rndis_set_param_dev(rndis->config, net,
&rndis->port.cdc_filter);
} else
goto fail;
return 0;
fail:
return -EINVAL;
}
static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct f_acm *acm = func_to_acm(f);
struct usb_composite_dev *cdev = f->config->cdev;
bool is_setting = 0;
int ret;
D("+\n");
/* we know alt == 0, so this is an activation or a reset */
/* if it is single interface, intf, acm->ctrl_id and acm->data_id
* are the same, so we can setting data and notify interface in the same time.
*
* if it is multi interface, acm->ctrl_id and acm->data_id are different,
* so the setting is go ahead in different times.
*/
if (intf == acm->ctrl_id) {
is_setting = 1;
if (acm->notify) {
if (acm->notify->driver_data) {
VDBG(cdev, "reset acm control interface %d\n", intf);
usb_ep_disable(acm->notify);
} else {
VDBG(cdev, "init acm ctrl interface %d\n", intf);
if (config_ep_by_speed(cdev->gadget, f, acm->notify))
return -EINVAL;
}
ret = usb_ep_enable(acm->notify);
if (ret < 0) {
ERROR(cdev, "Enable acm interface ep failed\n");
return ret;
}
acm->notify->driver_data = acm;
}
}
if (intf == acm->data_id) {
is_setting = 1;
if (acm->port.in->driver_data) {
DBG(cdev, "reset acm ttyGS%d\n", acm->port_num);
gacm_cdev_disconnect(&acm->port);
}
if (!acm->port.in->desc || !acm->port.out->desc) {
DBG(cdev, "activate acm ttyGS%d\n", acm->port_num);
if (config_ep_by_speed(cdev->gadget, f,
acm->port.in) ||
config_ep_by_speed(cdev->gadget, f,
acm->port.out)) {
acm->port.in->desc = NULL;
acm->port.out->desc = NULL;
return -EINVAL;
}
}
gacm_cdev_connect(&acm->port, acm->port_num);
bsp_usb_set_enum_stat(acm->data_id, 1);
}
if (!is_setting)
return -EINVAL;
D("-\n");
return 0;
}
