/* forward declarations */
static void
cyas_ep_reset(
- struct cyasgadget_ep *an_ep) ;
+ struct cyasgadget_ep *an_ep);
static int
cyasgadget_fifo_status(
- struct usb_ep *_ep) ;
+ struct usb_ep *_ep);
static void
cyasgadget_stallcallback(
void *evdata
)
{
- cyasgadget *cy_as_dev ;
+ cyasgadget *cy_as_dev;
#ifndef WESTBRIDGE_NDEBUG
struct usb_ctrlrequest *ctrlreq;
#endif
/* cy_as_dev = container_of(h, cyasgadget, dev_handle); */
- cy_as_dev = cy_as_gadget_controller ;
+ cy_as_dev = cy_as_gadget_controller;
switch (ev) {
case cy_as_event_usb_suspend:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_suspend received\n") ;
+ "<1>_cy_as_event_usb_suspend received\n");
#endif
- cy_as_dev->driver->suspend(&cy_as_dev->gadget) ;
+ cy_as_dev->driver->suspend(&cy_as_dev->gadget);
break;
case cy_as_event_usb_resume:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_resume received\n") ;
+ "<1>_cy_as_event_usb_resume received\n");
#endif
- cy_as_dev->driver->resume(&cy_as_dev->gadget) ;
+ cy_as_dev->driver->resume(&cy_as_dev->gadget);
break;
case cy_as_event_usb_reset:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_reset received\n") ;
+ "<1>_cy_as_event_usb_reset received\n");
#endif
break;
case cy_as_event_usb_speed_change:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_speed_change received\n") ;
+ "<1>_cy_as_event_usb_speed_change received\n");
#endif
break;
case cy_as_event_usb_set_config:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_set_config received\n") ;
+ "<1>_cy_as_event_usb_set_config received\n");
#endif
break;
ctrlreq->wValue,
ctrlreq->wIndex,
ctrlreq->wLength
- ) ;
+ );
#endif
cy_as_dev->outsetupreq = 0;
if ((((uint8_t *)evdata)[0] & USB_DIR_IN) == USB_DIR_OUT)
cy_as_dev->outsetupreq = 1;
cy_as_dev->driver->setup(&cy_as_dev->gadget,
- (struct usb_ctrlrequest *)evdata) ;
+ (struct usb_ctrlrequest *)evdata);
break;
case cy_as_event_usb_status_packet:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_status_packet received\n") ;
+ "<1>_cy_as_event_usb_status_packet received\n");
#endif
break;
case cy_as_event_usb_inquiry_before:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_inquiry_before received\n") ;
+ "<1>_cy_as_event_usb_inquiry_before received\n");
#endif
break;
case cy_as_event_usb_inquiry_after:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_inquiry_after received\n") ;
+ "<1>_cy_as_event_usb_inquiry_after received\n");
#endif
break;
case cy_as_event_usb_start_stop:
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
- "<1>_cy_as_event_usb_start_stop received\n") ;
+ "<1>_cy_as_event_usb_start_stop received\n");
#endif
break;
)
{
- cyasgadget *dev = cy_as_gadget_controller ;
+ cyasgadget *dev = cy_as_gadget_controller;
(void) handle;
switch (evtype) {
case cy_as_mtp_send_object_complete:
{
cy_as_mtp_send_object_complete_data *send_obj_data =
- (cy_as_mtp_send_object_complete_data *) evdata ;
+ (cy_as_mtp_send_object_complete_data *) evdata;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
dev->tmtp_send_complete_data.status =
send_obj_data->status;
dev->tmtp_send_complete_data.transaction_id =
- send_obj_data->transaction_id ;
- dev->tmtp_send_complete = cy_true ;
+ send_obj_data->transaction_id;
+ dev->tmtp_send_complete = cy_true;
break;
}
case cy_as_mtp_get_object_complete:
{
cy_as_mtp_get_object_complete_data *get_obj_data =
- (cy_as_mtp_get_object_complete_data *) evdata ;
+ (cy_as_mtp_get_object_complete_data *) evdata;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
dev->tmtp_get_complete_data.byte_count =
get_obj_data->byte_count;
dev->tmtp_get_complete_data.status =
- get_obj_data->status ;
- dev->tmtp_get_complete = cy_true ;
+ get_obj_data->status;
+ dev->tmtp_get_complete = cy_true;
break;
}
case cy_as_mtp_block_table_needed:
{
- dev->tmtp_need_new_blk_tbl = cy_true ;
+ dev->tmtp_need_new_blk_tbl = cy_true;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
"<6>MTP EVENT: cy_as_mtp_block_table_needed\n");
void *buf,
cy_as_return_status_t status)
{
- cyasgadget_ep *an_ep;
- cyasgadget_req *an_req;
- cyasgadget *cy_as_dev ;
- unsigned stopped ;
- unsigned long flags;
- (void)buf ;
-
- cy_as_dev = cy_as_gadget_controller ;
- if (cy_as_dev->driver == NULL)
+ cyasgadget_ep *an_ep;
+ cyasgadget_req *an_req;
+ cyasgadget *cy_as_dev;
+ unsigned stopped;
+ unsigned long flags;
+ (void)buf;
+
+ cy_as_dev = cy_as_gadget_controller;
+ if (cy_as_dev->driver == NULL)
return;
- an_ep = &cy_as_dev->an_gadget_ep[ep] ;
- spin_lock_irqsave(&cy_as_dev->lock, flags);
- stopped = an_ep->stopped ;
+ an_ep = &cy_as_dev->an_gadget_ep[ep];
+ spin_lock_irqsave(&cy_as_dev->lock, flags);
+ stopped = an_ep->stopped;
#ifndef WESTBRIDGE_NDEBUG
- cy_as_hal_print_message(
+ cy_as_hal_print_message(
"%s: ep=%d, count=%d, "
- "status=%d\n", __func__, ep, count, status) ;
+ "status=%d\n", __func__, ep, count, status);
#endif
- an_req = list_entry(an_ep->queue.next,
- cyasgadget_req, queue) ;
- list_del_init(&an_req->queue) ;
+ an_req = list_entry(an_ep->queue.next,
+ cyasgadget_req, queue);
+ list_del_init(&an_req->queue);
- if (status == CY_AS_ERROR_SUCCESS)
+ if (status == CY_AS_ERROR_SUCCESS)
an_req->req.status = 0;
- else
+ else
an_req->req.status = -status;
- an_req->req.actual = count ;
- an_ep->stopped = 1;
+ an_req->req.actual = count;
+ an_ep->stopped = 1;
spin_unlock_irqrestore(&cy_as_dev->lock, flags);
- an_req->req.complete(&an_ep->usb_ep_inst, &an_req->req);
+ an_req->req.complete(&an_ep->usb_ep_inst, &an_req->req);
- an_ep->stopped = stopped;
+ an_ep->stopped = stopped;
}
/*called when the write of a setup packet has been completed*/
{
cyasgadget_ep *an_ep;
cyasgadget_req *an_req;
- cyasgadget *cy_as_dev ;
- unsigned stopped ;
+ cyasgadget *cy_as_dev;
+ unsigned stopped;
unsigned long flags;
- (void)buf ;
+ (void)buf;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>%s called status=0x%x\n",
__func__, status);
#endif
- cy_as_dev = cy_as_gadget_controller ;
+ cy_as_dev = cy_as_gadget_controller;
if (cy_as_dev->driver == NULL)
return;
- an_ep = &cy_as_dev->an_gadget_ep[ep] ;
+ an_ep = &cy_as_dev->an_gadget_ep[ep];
spin_lock_irqsave(&cy_as_dev->lock, flags);
- stopped = an_ep->stopped ;
+ stopped = an_ep->stopped;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("setup_write_callback: ep=%d, "
- "count=%d, status=%d\n", ep, count, status) ;
+ "count=%d, status=%d\n", ep, count, status);
#endif
- an_req = list_entry(an_ep->queue.next, cyasgadget_req, queue) ;
- list_del_init(&an_req->queue) ;
+ an_req = list_entry(an_ep->queue.next, cyasgadget_req, queue);
+ list_del_init(&an_req->queue);
- an_req->req.actual = count ;
- an_req->req.status = 0 ;
+ an_req->req.actual = count;
+ an_req->req.status = 0;
an_ep->stopped = 1;
spin_unlock_irqrestore(&cy_as_dev->lock, flags);
{
cyasgadget_ep *an_ep;
cyasgadget_req *an_req;
- cyasgadget *cy_as_dev ;
- unsigned stopped ;
- cy_as_return_status_t ret ;
+ cyasgadget *cy_as_dev;
+ unsigned stopped;
+ cy_as_return_status_t ret;
unsigned long flags;
- (void)h ;
- (void)buf ;
+ (void)h;
+ (void)buf;
- cy_as_dev = cy_as_gadget_controller ;
+ cy_as_dev = cy_as_gadget_controller;
if (cy_as_dev->driver == NULL)
return;
- an_ep = &cy_as_dev->an_gadget_ep[ep] ;
- stopped = an_ep->stopped ;
+ an_ep = &cy_as_dev->an_gadget_ep[ep];
+ stopped = an_ep->stopped;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: ep=%d, count=%d, status=%d\n",
- __func__, ep, count, status) ;
+ __func__, ep, count, status);
#endif
if (status == CY_AS_ERROR_CANCELED)
- return ;
+ return;
spin_lock_irqsave(&cy_as_dev->lock, flags);
- an_req = list_entry(an_ep->queue.next, cyasgadget_req, queue) ;
- list_del_init(&an_req->queue) ;
+ an_req = list_entry(an_ep->queue.next, cyasgadget_req, queue);
+ list_del_init(&an_req->queue);
if (status == CY_AS_ERROR_SUCCESS)
- an_req->req.status = 0 ;
+ an_req->req.status = 0;
else
- an_req->req.status = -status ;
+ an_req->req.status = -status;
an_req->complete = 1;
- an_req->req.actual = count ;
+ an_req->req.actual = count;
an_ep->stopped = 1;
spin_unlock_irqrestore(&cy_as_dev->lock, flags);
* again, so as to not miss any data packets. */
if (!an_ep->stopped) {
spin_lock_irqsave(&cy_as_dev->lock, flags);
- an_req = 0 ;
+ an_req = 0;
if (!list_empty(&an_ep->queue))
an_req = list_entry(an_ep->queue.next,
- cyasgadget_req, queue) ;
+ cyasgadget_req, queue);
spin_unlock_irqrestore(&cy_as_dev->lock, flags);
if (ret != CY_AS_ERROR_SUCCESS)
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_read_data_async failed "
- "with error code %d\n", ret) ;
+ "with error code %d\n", ret);
else
- an_req->req.status = -EALREADY ;
+ an_req->req.status = -EALREADY;
}
}
}
{
cyasgadget_ep *an_ep;
cyasgadget_req *an_req;
- cyasgadget *cy_as_dev ;
+ cyasgadget *cy_as_dev;
unsigned stopped = 0;
- cy_as_return_status_t ret ;
+ cy_as_return_status_t ret;
unsigned long flags;
- (void)h ;
- (void)buf ;
+ (void)h;
+ (void)buf;
- cy_as_dev = cy_as_gadget_controller ;
+ cy_as_dev = cy_as_gadget_controller;
if (cy_as_dev->driver == NULL)
return;
- an_ep = &cy_as_dev->an_gadget_ep[ep] ;
+ an_ep = &cy_as_dev->an_gadget_ep[ep];
if (status == CY_AS_ERROR_CANCELED)
- return ;
+ return;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: ep=%d, count=%d, status=%d\n",
- __func__, ep, count, status) ;
+ __func__, ep, count, status);
#endif
spin_lock_irqsave(&cy_as_dev->lock, flags);
- an_req = list_entry(an_ep->queue.next, cyasgadget_req, queue) ;
- list_del_init(&an_req->queue) ;
- an_req->req.actual = count ;
+ an_req = list_entry(an_ep->queue.next, cyasgadget_req, queue);
+ list_del_init(&an_req->queue);
+ an_req->req.actual = count;
/* Verify the status value before setting req.status to zero */
if (status == CY_AS_ERROR_SUCCESS)
- an_req->req.status = 0 ;
+ an_req->req.status = 0;
else
- an_req->req.status = -status ;
+ an_req->req.status = -status;
an_ep->stopped = 1;
miss any data packets. */
if (!an_ep->stopped) {
spin_lock_irqsave(&cy_as_dev->lock, flags);
- an_req = 0 ;
+ an_req = 0;
if (!list_empty(&an_ep->queue))
an_req = list_entry(an_ep->queue.next,
- cyasgadget_req, queue) ;
+ cyasgadget_req, queue);
spin_unlock_irqrestore(&cy_as_dev->lock, flags);
if ((an_req) && (an_req->req.status == -EINPROGRESS)) {
if (ret != CY_AS_ERROR_SUCCESS)
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_write_data_async "
- "failed with error code %d\n", ret) ;
+ "failed with error code %d\n", ret);
else
- an_req->req.status = -EALREADY ;
+ an_req->req.status = -EALREADY;
}
}
}
#ifndef WESTBRIDGE_NDEBUG
if (status != CY_AS_ERROR_SUCCESS)
cy_as_hal_print_message("<1>_set/_clear stall "
- "failed with status %d\n", status) ;
+ "failed with status %d\n", status);
#endif
}
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_end_point_config EP %s mismatch "
- "on enabled\n", an_ep->usb_ep_inst.name) ;
+ "on enabled\n", an_ep->usb_ep_inst.name);
#endif
return -EINVAL;
}
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_end_point_config EP %s mismatch "
"on type %d %d\n", an_ep->usb_ep_inst.name,
- an_ep->cyepconfig.type, cy_as_usb_iso) ;
+ an_ep->cyepconfig.type, cy_as_usb_iso);
#endif
return -EINVAL;
}
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_end_point_config EP %s mismatch "
"on type %d %d\n", an_ep->usb_ep_inst.name,
- an_ep->cyepconfig.type, cy_as_usb_int) ;
+ an_ep->cyepconfig.type, cy_as_usb_int);
#endif
return -EINVAL;
}
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_end_point_config EP %s mismatch "
"on type %d %d\n", an_ep->usb_ep_inst.name,
- an_ep->cyepconfig.type, cy_as_usb_bulk) ;
+ an_ep->cyepconfig.type, cy_as_usb_bulk);
#endif
return -EINVAL;
}
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_end_point_config EP %s mismatch "
"on dir %d %d\n", an_ep->usb_ep_inst.name,
- an_ep->cyepconfig.dir, cy_as_usb_in) ;
+ an_ep->cyepconfig.dir, cy_as_usb_in);
#endif
return -EINVAL;
} else if ((an_ep->cyepconfig.dir == cy_as_usb_out) &&
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_end_point_config EP %s mismatch "
"on dir %d %d\n", an_ep->usb_ep_inst.name,
- an_ep->cyepconfig.dir, cy_as_usb_out) ;
+ an_ep->cyepconfig.dir, cy_as_usb_out);
#endif
return -EINVAL;
}
struct usb_request *_req
)
{
- cyasgadget_req *an_req ;
+ cyasgadget_req *an_req;
if (!_ep || !_req)
- return ;
+ return;
- an_req = container_of(_req, cyasgadget_req, req) ;
+ an_req = container_of(_req, cyasgadget_req, req);
kfree(an_req);
}
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_write_data_async being called "
- "on ep %d\n", as_ep->num) ;
+ "on ep %d\n", as_ep->num);
#endif
ret = cy_as_usb_write_data_async(cy_as_dev->dev_handle,
as_ep->num, _req->length, _req->buf,
- cy_false, cyasgadget_writecallback) ;
+ cy_false, cyasgadget_writecallback);
if (ret != CY_AS_ERROR_SUCCESS)
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_write_data_async failed with "
- "error code %d\n", ret) ;
+ "error code %d\n", ret);
else
- _req->status = -EALREADY ;
+ _req->status = -EALREADY;
} else if (as_ep->num == 0) {
/*
ret = cy_as_usb_write_data_async(cy_as_dev->dev_handle,
as_ep->num, _req->length, _req->buf, cy_false,
- cyasgadget_setupwritecallback) ;
+ cyasgadget_setupwritecallback);
if (ret != CY_AS_ERROR_SUCCESS)
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_write_data_async failed with error "
- "code %d\n", ret) ;
+ "code %d\n", ret);
*/
if ((cy_as_dev->outsetupreq) && (_req->length)) {
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_read_data_async "
"being called on ep %d\n",
- as_ep->num) ;
+ as_ep->num);
#endif
ret = cy_as_usb_read_data_async (
if (ret != CY_AS_ERROR_SUCCESS)
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_read_data_async failed with "
- "error code %d\n", ret) ;
+ "error code %d\n", ret);
} else {
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_write_data_async "
"being called on ep %d\n",
- as_ep->num) ;
+ as_ep->num);
#endif
ret = cy_as_usb_write_data_async(cy_as_dev->dev_handle,
as_ep->num, _req->length, _req->buf, cy_false,
- cyasgadget_setupwritecallback) ;
+ cyasgadget_setupwritecallback);
if (ret != CY_AS_ERROR_SUCCESS)
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_write_data_async failed with "
- "error code %d\n", ret) ;
+ "error code %d\n", ret);
}
} else if (list_empty(&as_ep->queue)) {
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_read_data_async being called since "
- "ep queue empty%d\n", ret) ;
+ "ep queue empty%d\n", ret);
#endif
ret = cy_as_usb_read_data_async(cy_as_dev->dev_handle,
as_ep->num, cy_false, _req->length, _req->buf,
- cyasgadget_readcallback) ;
+ cyasgadget_readcallback);
if (ret != CY_AS_ERROR_SUCCESS)
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_read_data_async failed with error "
- "code %d\n", ret) ;
+ "code %d\n", ret);
else
- _req->status = -EALREADY ;
+ _req->status = -EALREADY;
}
spin_lock_irqsave(&cy_as_dev->lock, flags);
cyasgadget_ep *an_ep;
cyasgadget *dev;
an_ep = container_of(_ep, cyasgadget_ep, usb_ep_inst);
- dev = an_ep->dev ;
+ dev = an_ep->dev;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>%s called\n", __func__);
else {
if (value) {
cy_as_usb_set_stall(an_ep->dev->dev_handle,
- an_ep->num, cyasgadget_stallcallback, 0) ;
+ an_ep->num, cyasgadget_stallcallback, 0);
} else {
cy_as_usb_clear_stall(an_ep->dev->dev_handle,
- an_ep->num, cyasgadget_stallcallback, 0) ;
+ an_ep->num, cyasgadget_stallcallback, 0);
}
}
cy_as_hal_print_message("<1>%s called\n", __func__);
#endif
- return 0 ;
+ return 0;
}
static void cyasgadget_fifo_flush(
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>%s called\n", __func__);
#endif
- return 0 ;
+ return 0;
}
static int cyasgadget_wakeup(
int is_on
)
{
- struct cyasgadget *cy_as_dev ;
+ struct cyasgadget *cy_as_dev;
unsigned long flags;
#ifndef WESTBRIDGE_NDEBUG
spin_lock_irqsave(&cy_as_dev->lock, flags);
cy_as_dev->softconnect = (is_on != 0);
if (is_on)
- cy_as_usb_connect(cy_as_dev->dev_handle, 0, 0) ;
+ cy_as_usb_connect(cy_as_dev->dev_handle, 0, 0);
else
- cy_as_usb_disconnect(cy_as_dev->dev_handle, 0, 0) ;
+ cy_as_usb_disconnect(cy_as_dev->dev_handle, 0, 0);
spin_unlock_irqrestore(&cy_as_dev->lock, flags);
int err = 0;
int retval = 0;
int ret_stat = 0;
- cyasgadget *dev = cy_as_gadget_controller ;
+ cyasgadget *dev = cy_as_gadget_controller;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>%s called, code=%d, param=%ld\n",
case CYASGADGET_GETMTPSTATUS:
{
cy_as_gadget_ioctl_tmtp_status *usr_d =
- (cy_as_gadget_ioctl_tmtp_status *)param ;
+ (cy_as_gadget_ioctl_tmtp_status *)param;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: got CYASGADGET_GETMTPSTATUS\n",
__func__);
#endif
- dev->tmtp_send_complete = 0 ;
- dev->tmtp_get_complete = 0 ;
- dev->tmtp_need_new_blk_tbl = 0 ;
+ dev->tmtp_send_complete = 0;
+ dev->tmtp_get_complete = 0;
+ dev->tmtp_need_new_blk_tbl = 0;
break;
}
case CYASGADGET_INITSOJ:
{
- cy_as_gadget_ioctl_i_s_o_j_d k_d ;
+ cy_as_gadget_ioctl_i_s_o_j_d k_d;
cy_as_gadget_ioctl_i_s_o_j_d *usr_d =
- (cy_as_gadget_ioctl_i_s_o_j_d *)param ;
- cy_as_mtp_block_table blk_table ;
- struct scatterlist sg ;
+ (cy_as_gadget_ioctl_i_s_o_j_d *)param;
+ cy_as_mtp_block_table blk_table;
+ struct scatterlist sg;
char *alloc_filename;
struct file *file_to_allocate;
bh.b_state = 0;
bh.b_blocknr = 0;
/* block size is arbitrary , we'll use sector size*/
- bh.b_size = SECTOR_SIZE ;
+ bh.b_size = SECTOR_SIZE;
filp_close(file_to_allocate, NULL);
- dev->tmtp_send_complete = 0 ;
- dev->tmtp_need_new_blk_tbl = 0 ;
+ dev->tmtp_send_complete = 0;
+ dev->tmtp_need_new_blk_tbl = 0;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
}
case CYASGADGET_INITGOJ:
{
- cy_as_gadget_ioctl_i_g_o_j_d k_d ;
+ cy_as_gadget_ioctl_i_g_o_j_d k_d;
cy_as_gadget_ioctl_i_g_o_j_d *usr_d =
- (cy_as_gadget_ioctl_i_g_o_j_d *)param ;
- cy_as_mtp_block_table blk_table ;
- struct scatterlist sg ;
+ (cy_as_gadget_ioctl_i_g_o_j_d *)param;
+ cy_as_mtp_block_table blk_table;
+ struct scatterlist sg;
char *map_filename;
struct file *file_to_map;
{
int i = 0;
- for (i = 0 ; i <= blk_table_idx; i++) {
+ for (i = 0; i <= blk_table_idx; i++) {
cy_as_hal_print_message(
"%s %d 0x%x 0x%x\n",
__func__, i,
filp_close(file_to_map, NULL);
- dev->tmtp_get_complete = 0 ;
- dev->tmtp_need_new_blk_tbl = 0 ;
+ dev->tmtp_get_complete = 0;
+ dev->tmtp_need_new_blk_tbl = 0;
ret_stat = __put_user(
blk_table.start_blocks[blk_table_idx],
case CYASGADGET_CANCELSOJ:
{
cy_as_gadget_ioctl_cancel *usr_d =
- (cy_as_gadget_ioctl_cancel *)param ;
+ (cy_as_gadget_ioctl_cancel *)param;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
case CYASGADGET_CANCELGOJ:
{
cy_as_gadget_ioctl_cancel *usr_d =
- (cy_as_gadget_ioctl_cancel *)param ;
+ (cy_as_gadget_ioctl_cancel *)param;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: got CYASGADGET_CANCELGOJ\n",
an_ep->desc = NULL;
INIT_LIST_HEAD(&an_ep->queue);
- an_ep->stopped = 0 ;
- an_ep->is_in = 0 ;
- an_ep->is_iso = 0 ;
+ an_ep->stopped = 0;
+ an_ep->is_in = 0;
+ an_ep->is_iso = 0;
an_ep->usb_ep_inst.maxpacket = ~0;
an_ep->usb_ep_inst.ops = &cyasgadget_ep_ops;
}
)
{
cy_as_return_status_t ret;
- cy_as_usb_enum_control config ;
+ cy_as_usb_enum_control config;
#ifndef WESTBRIDGE_NDEBUG
- cy_as_device *dev_p = (cy_as_device *)cy_as_dev->dev_handle ;
+ cy_as_device *dev_p = (cy_as_device *)cy_as_dev->dev_handle;
cy_as_hal_print_message("<1>%s called mtp_firmware=0x%x\n",
__func__, dev_p->is_mtp_firmware);
#endif
ret = cy_as_misc_release_resource(cy_as_dev->dev_handle,
- cy_as_bus_u_s_b) ;
+ cy_as_bus_u_s_b);
if (ret != CY_AS_ERROR_SUCCESS && ret !=
CY_AS_ERROR_RESOURCE_NOT_OWNED) {
cy_as_hal_print_message("<1>_cy_as_gadget: cannot "
"release usb resource: failed with error code %d\n",
- ret) ;
- return ;
+ ret);
+ return;
}
- cy_as_dev->gadget.speed = USB_SPEED_HIGH ;
+ cy_as_dev->gadget.speed = USB_SPEED_HIGH;
- ret = cy_as_usb_start(cy_as_dev->dev_handle, 0, 0) ;
+ ret = cy_as_usb_start(cy_as_dev->dev_handle, 0, 0);
if (ret != CY_AS_ERROR_SUCCESS) {
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_start failed with error code %d\n",
- ret) ;
- return ;
+ ret);
+ return;
}
/* P port will do enumeration, not West Bridge */
- config.antioch_enumeration = cy_false ;
+ config.antioch_enumeration = cy_false;
/* 1 2 : 1-BUS_NUM , 2:Storage_device number, SD - is bus 1*/
/* TODO: add module param to enumerate mass storage */
- config.mass_storage_interface = 0 ;
+ config.mass_storage_interface = 0;
if (append_mtp) {
ret = cy_as_mtp_start(cy_as_dev->dev_handle,
if (ret == CY_AS_ERROR_SUCCESS) {
cy_as_hal_print_message("MTP start passed, enumerating "
"MTP interface\n");
- config.mtp_interface = append_mtp ;
+ config.mtp_interface = append_mtp;
/*Do not enumerate NAND storage*/
config.devices_to_enumerate[0][0] = cy_false;
} else {
cy_as_hal_print_message("MTP start not attempted, not "
"enumerating MTP interface\n");
- config.mtp_interface = 0 ;
+ config.mtp_interface = 0;
/* enumerate mass storage based on module parameters */
config.devices_to_enumerate[0][0] = msc_enum_bus_0;
config.devices_to_enumerate[1][0] = msc_enum_bus_1;
}
ret = cy_as_usb_set_enum_config(cy_as_dev->dev_handle,
- &config, 0, 0) ;
+ &config, 0, 0);
if (ret != CY_AS_ERROR_SUCCESS) {
cy_as_hal_print_message("<1>_cy_as_gadget: "
"cy_as_usb_set_enum_config failed with error "
- "code %d\n", ret) ;
- return ;
+ "code %d\n", ret);
+ return;
}
cy_as_usb_set_physical_configuration(cy_as_dev->dev_handle, 1);
int index = 0;
cyasgadget_ep *an_ep_p;
cy_as_return_status_t ret;
- cy_as_device *dev_p = (cy_as_device *)cy_as_dev->dev_handle ;
+ cy_as_device *dev_p = (cy_as_device *)cy_as_dev->dev_handle;
INIT_LIST_HEAD(&cy_as_dev->gadget.ep_list);
/* Init the end points */
for (index = 1; index <= 15; index++) {
- an_ep_p = &cy_as_dev->an_gadget_ep[index] ;
- cyas_ep_reset(an_ep_p) ;
- an_ep_p->usb_ep_inst.name = cy_as_ep_names[index] ;
- an_ep_p->dev = cy_as_dev ;
- an_ep_p->num = index ;
+ an_ep_p = &cy_as_dev->an_gadget_ep[index];
+ cyas_ep_reset(an_ep_p);
+ an_ep_p->usb_ep_inst.name = cy_as_ep_names[index];
+ an_ep_p->dev = cy_as_dev;
+ an_ep_p->num = index;
memset(&an_ep_p->cyepconfig, 0, sizeof(an_ep_p->cyepconfig));
/* EP0, EPs 2,4,6,8 need not be added */
if ((index <= 8) && (index % 2 == 0) &&
(!dev_p->is_mtp_firmware)) {
/* EP0 is 64 and EPs 2,4,6,8 not allowed */
- cy_as_dev->an_gadget_ep[index].fifo_size = 0 ;
+ cy_as_dev->an_gadget_ep[index].fifo_size = 0;
} else {
if (index == 1)
an_ep_p->fifo_size = 64;
else
- an_ep_p->fifo_size = 512 ;
+ an_ep_p->fifo_size = 512;
list_add_tail(&an_ep_p->usb_ep_inst.ep_list,
&cy_as_dev->gadget.ep_list);
}
* by gadget after connect), therefore need to set config in
* initialization and verify compatibility in ep_enable,
* kick up error otherwise*/
- an_ep_p = &cy_as_dev->an_gadget_ep[3] ;
- an_ep_p->cyepconfig.enabled = cy_true ;
- an_ep_p->cyepconfig.dir = cy_as_usb_out ;
- an_ep_p->cyepconfig.type = cy_as_usb_bulk ;
- an_ep_p->cyepconfig.size = 0 ;
- an_ep_p->cyepconfig.physical = 1 ;
+ an_ep_p = &cy_as_dev->an_gadget_ep[3];
+ an_ep_p->cyepconfig.enabled = cy_true;
+ an_ep_p->cyepconfig.dir = cy_as_usb_out;
+ an_ep_p->cyepconfig.type = cy_as_usb_bulk;
+ an_ep_p->cyepconfig.size = 0;
+ an_ep_p->cyepconfig.physical = 1;
ret = cy_as_usb_set_end_point_config(an_ep_p->dev->dev_handle,
- 3, &an_ep_p->cyepconfig) ;
+ 3, &an_ep_p->cyepconfig);
if (ret != CY_AS_ERROR_SUCCESS) {
cy_as_hal_print_message("cy_as_usb_set_end_point_config "
- "failed with error code %d\n", ret) ;
+ "failed with error code %d\n", ret);
}
cy_as_usb_set_stall(an_ep_p->dev->dev_handle, 3, 0, 0);
- an_ep_p = &cy_as_dev->an_gadget_ep[5] ;
- an_ep_p->cyepconfig.enabled = cy_true ;
- an_ep_p->cyepconfig.dir = cy_as_usb_in ;
- an_ep_p->cyepconfig.type = cy_as_usb_bulk ;
- an_ep_p->cyepconfig.size = 0 ;
- an_ep_p->cyepconfig.physical = 2 ;
+ an_ep_p = &cy_as_dev->an_gadget_ep[5];
+ an_ep_p->cyepconfig.enabled = cy_true;
+ an_ep_p->cyepconfig.dir = cy_as_usb_in;
+ an_ep_p->cyepconfig.type = cy_as_usb_bulk;
+ an_ep_p->cyepconfig.size = 0;
+ an_ep_p->cyepconfig.physical = 2;
ret = cy_as_usb_set_end_point_config(an_ep_p->dev->dev_handle,
- 5, &an_ep_p->cyepconfig) ;
+ 5, &an_ep_p->cyepconfig);
if (ret != CY_AS_ERROR_SUCCESS) {
cy_as_hal_print_message("cy_as_usb_set_end_point_config "
- "failed with error code %d\n", ret) ;
+ "failed with error code %d\n", ret);
}
cy_as_usb_set_stall(an_ep_p->dev->dev_handle, 5, 0, 0);
- an_ep_p = &cy_as_dev->an_gadget_ep[9] ;
- an_ep_p->cyepconfig.enabled = cy_true ;
- an_ep_p->cyepconfig.dir = cy_as_usb_in ;
- an_ep_p->cyepconfig.type = cy_as_usb_bulk ;
- an_ep_p->cyepconfig.size = 0 ;
- an_ep_p->cyepconfig.physical = 4 ;
+ an_ep_p = &cy_as_dev->an_gadget_ep[9];
+ an_ep_p->cyepconfig.enabled = cy_true;
+ an_ep_p->cyepconfig.dir = cy_as_usb_in;
+ an_ep_p->cyepconfig.type = cy_as_usb_bulk;
+ an_ep_p->cyepconfig.size = 0;
+ an_ep_p->cyepconfig.physical = 4;
ret = cy_as_usb_set_end_point_config(an_ep_p->dev->dev_handle,
- 9, &an_ep_p->cyepconfig) ;
+ 9, &an_ep_p->cyepconfig);
if (ret != CY_AS_ERROR_SUCCESS) {
cy_as_hal_print_message("cy_as_usb_set_end_point_config "
- "failed with error code %d\n", ret) ;
+ "failed with error code %d\n", ret);
}
cy_as_usb_set_stall(an_ep_p->dev->dev_handle, 9, 0, 0);
if (dev_p->mtp_count != 0) {
/* these need to be set for compatibility with
* the gadget_enable logic */
- an_ep_p = &cy_as_dev->an_gadget_ep[2] ;
- an_ep_p->cyepconfig.enabled = cy_true ;
- an_ep_p->cyepconfig.dir = cy_as_usb_out ;
- an_ep_p->cyepconfig.type = cy_as_usb_bulk ;
- an_ep_p->cyepconfig.size = 0 ;
- an_ep_p->cyepconfig.physical = 0 ;
+ an_ep_p = &cy_as_dev->an_gadget_ep[2];
+ an_ep_p->cyepconfig.enabled = cy_true;
+ an_ep_p->cyepconfig.dir = cy_as_usb_out;
+ an_ep_p->cyepconfig.type = cy_as_usb_bulk;
+ an_ep_p->cyepconfig.size = 0;
+ an_ep_p->cyepconfig.physical = 0;
cy_as_usb_set_stall(an_ep_p->dev->dev_handle, 2, 0, 0);
- an_ep_p = &cy_as_dev->an_gadget_ep[6] ;
- an_ep_p->cyepconfig.enabled = cy_true ;
- an_ep_p->cyepconfig.dir = cy_as_usb_in ;
- an_ep_p->cyepconfig.type = cy_as_usb_bulk ;
- an_ep_p->cyepconfig.size = 0 ;
- an_ep_p->cyepconfig.physical = 0 ;
+ an_ep_p = &cy_as_dev->an_gadget_ep[6];
+ an_ep_p->cyepconfig.enabled = cy_true;
+ an_ep_p->cyepconfig.dir = cy_as_usb_in;
+ an_ep_p->cyepconfig.type = cy_as_usb_bulk;
+ an_ep_p->cyepconfig.size = 0;
+ an_ep_p->cyepconfig.physical = 0;
cy_as_usb_set_stall(an_ep_p->dev->dev_handle, 6, 0, 0);
}
- cyas_ep_reset(&cy_as_dev->an_gadget_ep[0]) ;
- cy_as_dev->an_gadget_ep[0].usb_ep_inst.name = cy_as_ep_names[0] ;
- cy_as_dev->an_gadget_ep[0].dev = cy_as_dev ;
- cy_as_dev->an_gadget_ep[0].num = 0 ;
- cy_as_dev->an_gadget_ep[0].fifo_size = 64 ;
+ cyas_ep_reset(&cy_as_dev->an_gadget_ep[0]);
+ cy_as_dev->an_gadget_ep[0].usb_ep_inst.name = cy_as_ep_names[0];
+ cy_as_dev->an_gadget_ep[0].dev = cy_as_dev;
+ cy_as_dev->an_gadget_ep[0].num = 0;
+ cy_as_dev->an_gadget_ep[0].fifo_size = 64;
cy_as_dev->an_gadget_ep[0].usb_ep_inst.maxpacket = 64;
cy_as_dev->gadget.ep0 = &cy_as_dev->an_gadget_ep[0].usb_ep_inst;
cyasgadget *dev
)
{
- cy_as_return_status_t ret ;
+ cy_as_return_status_t ret;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>%s called\n", __func__);
#endif
ret = cy_as_usb_register_callback(dev->dev_handle,
- cy_as_gadget_usb_event_callback) ;
+ cy_as_gadget_usb_event_callback);
if (ret != CY_AS_ERROR_SUCCESS) {
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: cy_as_usb_register_callback "
- "failed with error code %d\n", __func__, ret) ;
+ "failed with error code %d\n", __func__, ret);
#endif
- return ;
+ return;
}
- ret = cy_as_usb_commit_config(dev->dev_handle, 0, 0) ;
+ ret = cy_as_usb_commit_config(dev->dev_handle, 0, 0);
if (ret != CY_AS_ERROR_SUCCESS) {
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: cy_as_usb_commit_config "
- "failed with error code %d\n", __func__, ret) ;
+ "failed with error code %d\n", __func__, ret);
#endif
- return ;
+ return;
}
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: cy_as_usb_commit_config "
- "message sent\n", __func__) ;
+ "message sent\n", __func__);
#endif
- ret = cy_as_usb_connect(dev->dev_handle, 0, 0) ;
+ ret = cy_as_usb_connect(dev->dev_handle, 0, 0);
if (ret != CY_AS_ERROR_SUCCESS) {
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: cy_as_usb_connect failed "
- "with error code %d\n", __func__, ret) ;
+ "with error code %d\n", __func__, ret);
#endif
- return ;
+ return;
}
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("%s: cy_as_usb_connect message "
- "sent\n", __func__) ;
+ "sent\n", __func__);
#endif
}
int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
int (*bind)(struct usb_gadget *))
{
- cyasgadget *dev = cy_as_gadget_controller ;
+ cyasgadget *dev = cy_as_gadget_controller;
int retval;
#ifndef WESTBRIDGE_NDEBUG
dev->gadget.dev.driver = &driver->driver;
/* Do the needful */
- cyas_usb_reset(dev) ; /* External usb */
- cyas_usb_reinit(dev) ; /* Internal */
+ cyas_usb_reset(dev); /* External usb */
+ cyas_usb_reinit(dev); /* Internal */
retval = bind(&dev->gadget);
if (retval) {
cyasgadget_ep *an_ep
)
{
- cyasgadget *dev = cy_as_gadget_controller ;
+ cyasgadget *dev = cy_as_gadget_controller;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>%s called\n", __func__);
#endif
cy_as_usb_cancel_async(dev->dev_handle, an_ep->num);
- an_ep->stopped = 1 ;
+ an_ep->stopped = 1;
while (!list_empty(&an_ep->queue)) {
cyasgadget_req *an_req = list_entry
- (an_ep->queue.next, cyasgadget_req, queue) ;
- list_del_init(&an_req->queue) ;
- an_req->req.status = -ESHUTDOWN ;
- an_req->req.complete(&an_ep->usb_ep_inst, &an_req->req) ;
+ (an_ep->queue.next, cyasgadget_req, queue);
+ list_del_init(&an_req->queue);
+ an_req->req.status = -ESHUTDOWN;
+ an_req->req.complete(&an_ep->usb_ep_inst, &an_req->req);
}
}
struct usb_gadget_driver *driver
)
{
- int index ;
+ int index;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>%s called\n", __func__);
/* Stop hardware; prevent new request submissions;
* and kill any outstanding requests.
*/
- cy_as_usb_disconnect(dev->dev_handle, 0, 0) ;
+ cy_as_usb_disconnect(dev->dev_handle, 0, 0);
for (index = 3; index <= 7; index += 2) {
- cyasgadget_ep *an_ep_p = &dev->an_gadget_ep[index] ;
- cyasgadget_nuke(an_ep_p) ;
+ cyasgadget_ep *an_ep_p = &dev->an_gadget_ep[index];
+ cyasgadget_nuke(an_ep_p);
}
for (index = 9; index <= 15; index++) {
- cyasgadget_ep *an_ep_p = &dev->an_gadget_ep[index] ;
- cyasgadget_nuke(an_ep_p) ;
+ cyasgadget_ep *an_ep_p = &dev->an_gadget_ep[index];
+ cyasgadget_nuke(an_ep_p);
}
/* report disconnect; the driver is already quiesced */
#endif
/* Stop Usb */
- cy_as_usb_stop(dev->dev_handle, 0, 0) ;
+ cy_as_usb_stop(dev->dev_handle, 0, 0);
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("cy_as_usb_stop returned success");
struct usb_gadget_driver *driver
)
{
- cyasgadget *dev = cy_as_gadget_controller ;
+ cyasgadget *dev = cy_as_gadget_controller;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>%s called\n", __func__);
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("unregistered driver '%s'\n",
- driver->driver.name) ;
+ driver->driver.name);
#endif
return 0;
)
{
#ifndef WESTBRIDGE_NDEBUG
- cy_as_hal_print_message("<1>_cy_as_gadget deinitialize called\n") ;
+ cy_as_hal_print_message("<1>_cy_as_gadget deinitialize called\n");
#endif
if (!cy_as_dev) {
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message("<1>_cy_as_gadget_deinit: "
- "invalid cyasgadget device\n") ;
+ "invalid cyasgadget device\n");
#endif
- return ;
+ return;
}
if (cy_as_dev->driver) {
usb_gadget_unregister_driver(cy_as_dev->driver);
}
- kfree(cy_as_dev) ;
- cy_as_gadget_controller = NULL ;
+ kfree(cy_as_dev);
+ cy_as_gadget_controller = NULL;
}
/* Initialize gadget driver */
static int cyasgadget_initialize(void)
{
- cyasgadget *cy_as_dev = 0 ;
- int retval = 0 ;
+ cyasgadget *cy_as_dev = 0;
+ int retval = 0;
#ifndef WESTBRIDGE_NDEBUG
- cy_as_hal_print_message("<1>_cy_as_gadget [V1.1] initialize called\n") ;
+ cy_as_hal_print_message("<1>_cy_as_gadget [V1.1] initialize called\n");
#endif
if (cy_as_gadget_controller != 0) {
cy_as_hal_print_message("<1> cy_as_gadget: the device has "
- "already been initilaized. ignoring\n") ;
- return -EBUSY ;
+ "already been initilaized. ignoring\n");
+ return -EBUSY;
}
cy_as_dev = kzalloc(sizeof(cyasgadget), GFP_ATOMIC);
if (cy_as_dev == NULL) {
cy_as_hal_print_message("<1> cy_as_gadget: memory "
- "allocation failed\n") ;
+ "allocation failed\n");
return -ENOMEM;
}
cy_as_dev->gadget.name = cy_as_driver_name;
/* Get the device handle */
- cy_as_dev->dev_handle = cyasdevice_getdevhandle() ;
+ cy_as_dev->dev_handle = cyasdevice_getdevhandle();
if (0 == cy_as_dev->dev_handle) {
#ifndef NDEBUG
cy_as_hal_print_message("<1> cy_as_gadget: "
- "no west bridge device\n") ;
+ "no west bridge device\n");
#endif
- retval = -EFAULT ;
- goto done ;
+ retval = -EFAULT;
+ goto done;
}
/* We are done now */
- cy_as_gadget_controller = cy_as_dev ;
- return 0 ;
+ cy_as_gadget_controller = cy_as_dev;
+ return 0;
/*
* in case of an error
*/
done:
if (cy_as_dev)
- cyasgadget_deinit(cy_as_dev) ;
+ cyasgadget_deinit(cy_as_dev);
- return retval ;
+ return retval;
}
static int __init cyas_init(void)
git.openpandora.org / pandora-kernel.git / commitdiff