[PATCH -mm 2/3] USB: FHCI: Fix namespace pollution

Anton Vorontsov
2008-12-24T19:13:36Z

Prepend fhci_ prefixes to the external function names.

Signed-off-by: Anton Vorontsov <avorontsov@ru.mvista.com>
---
drivers/usb/host/fhci-hcd.c | 36 ++++++++--------
drivers/usb/host/fhci-hub.c | 29 +++++++------
drivers/usb/host/fhci-mem.c | 14 +++---
drivers/usb/host/fhci-q.c | 28 ++++++------
drivers/usb/host/fhci-sched.c | 94 ++++++++++++++++++++--------------------
drivers/usb/host/fhci-tds.c | 51 +++++++++++-----------
drivers/usb/host/fhci.h | 90 +++++++++++++++++++-------------------
7 files changed, 171 insertions(+), 171 deletions(-)

diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 47ac33f..269af3c 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -55,7 +55,7 @@ void fhci_stop_sof_timer(struct fhci_hcd *fhci)
fhci_dbg(fhci, "<- %s\n", __func__);
}

-u16 get_sof_timer_count(struct fhci_usb *usb)
+u16 fhci_get_sof_timer_count(struct fhci_usb *usb)
{
return be16_to_cpu(in_be16(&usb->fhci->regs->usb_sof_tmr) / 12);
}
@@ -67,12 +67,12 @@ static u32 endpoint_zero_init(struct fhci_usb *usb,
{
u32 rc;

- rc = create_endpoint(usb, data_mem, ring_len);
+ rc = fhci_create_ep(usb, data_mem, ring_len);
if (rc)
return rc;

/* inilialize endpoint registers */
- init_endpoint_registers(usb, usb->ep0, data_mem);
+ fhci_init_ep_registers(usb, usb->ep0, data_mem);

return 0;
}
@@ -133,12 +133,12 @@ static u32 fhci_usb_disable(struct fhci_hcd *fhci)
struct fhci_usb *usb = fhci->usb_lld;

fhci_usb_disable_interrupt(usb);
- usb_port_disable(fhci);
+ fhci_port_disable(fhci);

/* disable the usb controller */
if (usb->port_status == FHCI_PORT_FULL ||
usb->port_status == FHCI_PORT_LOW)
- device_disconnected_interrupt(fhci);
+ fhci_device_disconnected_interrupt(fhci);

clrbits8(&usb->fhci->regs->usb_mod, USB_MODE_EN);

@@ -213,7 +213,7 @@ static int fhci_mem_init(struct fhci_hcd *fhci)
error = 1;
break;
}
- recycle_empty_td(fhci, td);
+ fhci_recycle_empty_td(fhci, td);
}
for (i = 0; i < MAX_EDS; i++) {
struct ed *ed = kmalloc(sizeof(*ed), GFP_KERNEL);
@@ -222,7 +222,7 @@ static int fhci_mem_init(struct fhci_hcd *fhci)
error = 1;
break;
}
- recycle_empty_ed(fhci, ed);
+ fhci_recycle_empty_ed(fhci, ed);
}

if (error) {
@@ -242,8 +242,8 @@ static void fhci_usb_free(void *lld)
struct fhci_hcd *fhci = usb->fhci;

if (usb) {
- config_transceiver(fhci, FHCI_PORT_POWER_OFF);
- endpoint_zero_free(usb);
+ fhci_config_transceiver(fhci, FHCI_PORT_POWER_OFF);
+ fhci_ep0_free(usb);
kfree(usb->actual_frame);
kfree(usb);
}
@@ -312,7 +312,7 @@ static struct fhci_usb *fhci_create_lld(struct fhci_hcd *fhci)
usb->hc_list = fhci->hc_list;
usb->vroot_hub = fhci->vroot_hub;

- usb->transfer_confirm = transfer_confirm_callback;
+ usb->transfer_confirm = fhci_transfer_confirm_callback;

return usb;
}
@@ -449,7 +449,7 @@ static int fhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
urb->error_count = 0;
urb->hcpriv = urb_priv;

- queue_urb(fhci, urb);
+ fhci_queue_urb(fhci, urb);
err:
if (ret) {
kfree(urb_priv->tds);
@@ -493,7 +493,7 @@ static int fhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
/* already pending? */
urb_priv->ed->state = FHCI_ED_URB_DEL;
} else {
- urb_complete_free(fhci, urb);
+ fhci_urb_complete_free(fhci, urb);
}

out2:
@@ -514,10 +514,10 @@ static void fhci_endpoint_disable(struct usb_hcd *hcd,
ed = ep->hcpriv;
if (ed) {
while (ed->td_head != NULL) {
- struct td *td = remove_td_from_ed(ed);
- urb_complete_free(fhci, td->urb);
+ struct td *td = fhci_remove_td_from_ed(ed);
+ fhci_urb_complete_free(fhci, td->urb);
}
- recycle_empty_ed(fhci, ed);
+ fhci_recycle_empty_ed(fhci, ed);
ep->hcpriv = NULL;
}
spin_unlock_irqrestore(&fhci->lock, flags);
@@ -726,14 +726,14 @@ static int __devinit of_fhci_probe(struct of_device *ofdev,

dev_info(dev, "at 0x%p, irq %d\n", hcd->regs, usb_irq);

- config_transceiver(fhci, FHCI_PORT_POWER_OFF);
+ fhci_config_transceiver(fhci, FHCI_PORT_POWER_OFF);

/* Start with full-speed, if possible. */
if (fhci->fullspeed_clk != QE_CLK_NONE) {
- config_transceiver(fhci, FHCI_PORT_FULL);
+ fhci_config_transceiver(fhci, FHCI_PORT_FULL);
qe_usb_clock_set(fhci->fullspeed_clk, USB_CLOCK);
} else {
- config_transceiver(fhci, FHCI_PORT_LOW);
+ fhci_config_transceiver(fhci, FHCI_PORT_LOW);
qe_usb_clock_set(fhci->lowspeed_clk, USB_CLOCK >> 3);
}

diff --git a/drivers/usb/host/fhci-hub.c b/drivers/usb/host/fhci-hub.c
index 540e165..0cfaedc 100644
--- a/drivers/usb/host/fhci-hub.c
+++ b/drivers/usb/host/fhci-hub.c
@@ -52,7 +52,8 @@ static void fhci_gpio_set_value(struct fhci_hcd *fhci, int gpio_nr, bool on)
mdelay(5);
}

-void config_transceiver(struct fhci_hcd *fhci, enum fhci_port_status status)
+void fhci_config_transceiver(struct fhci_hcd *fhci,
+ enum fhci_port_status status)
{
fhci_dbg(fhci, "-> %s: %d\n", __func__, status);

@@ -79,7 +80,7 @@ void config_transceiver(struct fhci_hcd *fhci, enum fhci_port_status status)
}

/* disable the USB port by clearing the EN bit in the USBMOD register */
-void usb_port_disable(struct fhci_hcd *fhci)
+void fhci_port_disable(struct fhci_hcd *fhci)
{
struct fhci_usb *usb = (struct fhci_usb *)fhci->usb_lld;
enum fhci_port_status port_status;
@@ -88,7 +89,7 @@ void usb_port_disable(struct fhci_hcd *fhci)

fhci_stop_sof_timer(fhci);

- flush_all_transmissions(usb);
+ fhci_flush_all_transmissions(usb);

fhci_usb_disable_interrupt((struct fhci_usb *)fhci->usb_lld);
port_status = usb->port_status;
@@ -100,7 +101,7 @@ void usb_port_disable(struct fhci_hcd *fhci)

/* check if during the disconnection process attached new device */
if (port_status == FHCI_PORT_WAITING)
- device_connected_interrupt(fhci);
+ fhci_device_connected_interrupt(fhci);
usb->vroot_hub->port.wPortStatus &= ~USB_PORT_STAT_ENABLE;
usb->vroot_hub->port.wPortChange |= USB_PORT_STAT_C_ENABLE;
fhci_usb_enable_interrupt((struct fhci_usb *)fhci->usb_lld);
@@ -109,14 +110,14 @@ void usb_port_disable(struct fhci_hcd *fhci)
}

/* enable the USB port by setting the EN bit in the USBMOD register */
-void usb_port_enable(void *lld)
+void fhci_port_enable(void *lld)
{
struct fhci_usb *usb = (struct fhci_usb *)lld;
struct fhci_hcd *fhci = usb->fhci;

fhci_dbg(fhci, "-> %s\n", __func__);

- config_transceiver(fhci, usb->port_status);
+ fhci_config_transceiver(fhci, usb->port_status);

if ((usb->port_status != FHCI_PORT_FULL) &&
(usb->port_status != FHCI_PORT_LOW))
@@ -128,7 +129,7 @@ void usb_port_enable(void *lld)
fhci_dbg(fhci, "<- %s\n", __func__);
}

-void io_port_generate_reset(struct fhci_hcd *fhci)
+void fhci_io_port_generate_reset(struct fhci_hcd *fhci)
{
fhci_dbg(fhci, "-> %s\n", __func__);

@@ -146,7 +147,7 @@ void io_port_generate_reset(struct fhci_hcd *fhci)
}

/* generate the RESET condition on the bus */
-void usb_port_reset(void *lld)
+void fhci_port_reset(void *lld)
{
struct fhci_usb *usb = (struct fhci_usb *)lld;
struct fhci_hcd *fhci = usb->fhci;
@@ -164,7 +165,7 @@ void usb_port_reset(void *lld)
mask = in_be16(&fhci->regs->usb_mask);
out_be16(&fhci->regs->usb_mask, mask & (~USB_E_IDLE_MASK));

- io_port_generate_reset(fhci);
+ fhci_io_port_generate_reset(fhci);

/* enable interrupt on this endpoint */
out_be16(&fhci->regs->usb_mask, mask);
@@ -233,7 +234,7 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
case USB_PORT_FEAT_ENABLE:
fhci->vroot_hub->port.wPortStatus &=
~USB_PORT_STAT_ENABLE;
- usb_port_disable(fhci);
+ fhci_port_disable(fhci);
break;
case USB_PORT_FEAT_C_ENABLE:
fhci->vroot_hub->port.wPortChange &=
@@ -251,7 +252,7 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
case USB_PORT_FEAT_POWER:
fhci->vroot_hub->port.wPortStatus &=
~USB_PORT_STAT_POWER;
- config_transceiver(fhci, FHCI_PORT_POWER_OFF);
+ fhci_config_transceiver(fhci, FHCI_PORT_POWER_OFF);
break;
case USB_PORT_FEAT_C_CONNECTION:
fhci->vroot_hub->port.wPortChange &=
@@ -306,7 +307,7 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
case USB_PORT_FEAT_ENABLE:
fhci->vroot_hub->port.wPortStatus |=
USB_PORT_STAT_ENABLE;
- usb_port_enable(fhci->usb_lld);
+ fhci_port_enable(fhci->usb_lld);
break;
case USB_PORT_FEAT_SUSPEND:
fhci->vroot_hub->port.wPortStatus |=
@@ -316,7 +317,7 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
case USB_PORT_FEAT_RESET:
fhci->vroot_hub->port.wPortStatus |=
USB_PORT_STAT_RESET;
- usb_port_reset(fhci->usb_lld);
+ fhci_port_reset(fhci->usb_lld);
fhci->vroot_hub->port.wPortStatus |=
USB_PORT_STAT_ENABLE;
fhci->vroot_hub->port.wPortStatus &=
@@ -325,7 +326,7 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
case USB_PORT_FEAT_POWER:
fhci->vroot_hub->port.wPortStatus |=
USB_PORT_STAT_POWER;
- config_transceiver(fhci, FHCI_PORT_WAITING);
+ fhci_config_transceiver(fhci, FHCI_PORT_WAITING);
break;
default:
goto error;
diff --git a/drivers/usb/host/fhci-mem.c b/drivers/usb/host/fhci-mem.c
index c5ba0b0..2c0736c 100644
--- a/drivers/usb/host/fhci-mem.c
+++ b/drivers/usb/host/fhci-mem.c
@@ -55,13 +55,13 @@ static struct td *get_empty_td(struct fhci_hcd *fhci)
return td;
}

-void recycle_empty_td(struct fhci_hcd *fhci, struct td *td)
+void fhci_recycle_empty_td(struct fhci_hcd *fhci, struct td *td)
{
init_td(td);
list_add(&td->node, &fhci->empty_tds);
}

-struct ed *get_empty_ed(struct fhci_hcd *fhci)
+struct ed *fhci_get_empty_ed(struct fhci_hcd *fhci)
{
struct ed *ed;

@@ -79,16 +79,16 @@ struct ed *get_empty_ed(struct fhci_hcd *fhci)
return ed;
}

-void recycle_empty_ed(struct fhci_hcd *fhci, struct ed *ed)
+void fhci_recycle_empty_ed(struct fhci_hcd *fhci, struct ed *ed)
{
init_ed(ed);
list_add(&ed->node, &fhci->empty_eds);
}

-struct td *td_fill(struct fhci_hcd *fhci, struct urb *urb,
- struct urb_priv *urb_priv, struct ed *ed, u16 index,
- enum fhci_ta_type type, int toggle, u8 *data, u32 len,
- u16 interval, u16 start_frame, bool ioc)
+struct td *fhci_td_fill(struct fhci_hcd *fhci, struct urb *urb,
+ struct urb_priv *urb_priv, struct ed *ed, u16 index,
+ enum fhci_ta_type type, int toggle, u8 *data, u32 len,
+ u16 interval, u16 start_frame, bool ioc)
{
struct td *td = get_empty_td(fhci);

diff --git a/drivers/usb/host/fhci-q.c b/drivers/usb/host/fhci-q.c
index 1173318..b0a1446 100644
--- a/drivers/usb/host/fhci-q.c
+++ b/drivers/usb/host/fhci-q.c
@@ -53,12 +53,12 @@ static int status_to_error(u32 status)
return -EINVAL;
}

-void add_td_to_frame(struct fhci_time_frame *frame, struct td *td)
+void fhci_add_td_to_frame(struct fhci_time_frame *frame, struct td *td)
{
list_add_tail(&td->frame_lh, &frame->tds_list);
}

-void add_tds_to_ed(struct ed *ed, struct td **td_list, int number)
+void fhci_add_tds_to_ed(struct ed *ed, struct td **td_list, int number)
{
int i;

@@ -82,7 +82,7 @@ static struct td *peek_td_from_ed(struct ed *ed)
return td;
}

-struct td *remove_td_from_frame(struct fhci_time_frame *frame)
+struct td *fhci_remove_td_from_frame(struct fhci_time_frame *frame)
{
struct td *td;

@@ -95,7 +95,7 @@ struct td *remove_td_from_frame(struct fhci_time_frame *frame)
return td;
}

-struct td *peek_td_from_frame(struct fhci_time_frame *frame)
+struct td *fhci_peek_td_from_frame(struct fhci_time_frame *frame)
{
struct td *td;

@@ -107,7 +107,7 @@ struct td *peek_td_from_frame(struct fhci_time_frame *frame)
return td;
}

-struct td *remove_td_from_ed(struct ed *ed)
+struct td *fhci_remove_td_from_ed(struct ed *ed)
{
struct td *td;

@@ -127,7 +127,7 @@ struct td *remove_td_from_ed(struct ed *ed)
return td;
}

-struct td *remove_td_from_done_list(struct fhci_controller_list *p_list)
+struct td *fhci_remove_td_from_done_list(struct fhci_controller_list *p_list)
{
struct td *td;

@@ -140,7 +140,7 @@ struct td *remove_td_from_done_list(struct fhci_controller_list *p_list)
return td;
}

-void move_td_from_ed_to_done_list(struct fhci_usb *usb, struct ed *ed)
+void fhci_move_td_from_ed_to_done_list(struct fhci_usb *usb, struct ed *ed)
{
struct td *td;

@@ -169,7 +169,7 @@ static void free_urb_priv(struct fhci_hcd *fhci, struct urb *urb)

for (i = 0; i < urb_priv->num_of_tds; i++) {
list_del_init(&urb_priv->tds[i]->node);
- recycle_empty_td(fhci, urb_priv->tds[i]);
+ fhci_recycle_empty_td(fhci, urb_priv->tds[i]);
}

/* if this TD was the ED's head,find the next TD */
@@ -189,7 +189,7 @@ static void free_urb_priv(struct fhci_hcd *fhci, struct urb *urb)
}

/* this routine called to complete and free done URB */
-void urb_complete_free(struct fhci_hcd *fhci, struct urb *urb)
+void fhci_urb_complete_free(struct fhci_hcd *fhci, struct urb *urb)
{
free_urb_priv(fhci, urb);

@@ -214,7 +214,7 @@ void urb_complete_free(struct fhci_hcd *fhci, struct urb *urb)
* caculate transfer length/stats and update the urb
* Precondition: irqsafe(only for urb-?status locking)
*/
-void done_td(struct urb *urb, struct td *td)
+void fhci_done_td(struct urb *urb, struct td *td)
{
struct ed *ed = td->ed;
u32 cc = td->status;
@@ -265,20 +265,20 @@ void done_td(struct urb *urb, struct td *td)
}

/* there are some pedning request to unlink */
-void del_ed_list(struct fhci_hcd *fhci, struct ed *ed)
+void fhci_del_ed_list(struct fhci_hcd *fhci, struct ed *ed)
{
struct td *td = peek_td_from_ed(ed);
struct urb *urb = td->urb;
struct urb_priv *urb_priv = urb->hcpriv;

if (urb_priv->state == URB_DEL) {
- td = remove_td_from_ed(ed);
+ td = fhci_remove_td_from_ed(ed);
/* HC may have partly processed this TD */
if (td->status != USB_TD_INPROGRESS)
- done_td(urb, td);
+ fhci_done_td(urb, td);

/* URB is done;clean up */
if (++(urb_priv->tds_cnt) == urb_priv->num_of_tds)
- urb_complete_free(fhci, urb);
+ fhci_urb_complete_free(fhci, urb);
}
}
diff --git a/drivers/usb/host/fhci-sched.c b/drivers/usb/host/fhci-sched.c
index 4d39b40..bb63b68 100644
--- a/drivers/usb/host/fhci-sched.c
+++ b/drivers/usb/host/fhci-sched.c
@@ -41,7 +41,7 @@ static void recycle_frame(struct fhci_usb *usb, struct packet *pkt)
}

/* confirm submitted packet */
-void transaction_confirm(struct fhci_usb *usb, struct packet *pkt)
+void fhci_transaction_confirm(struct fhci_usb *usb, struct packet *pkt)
{
struct td *td;
struct packet *td_pkt;
@@ -49,7 +49,7 @@ void transaction_confirm(struct fhci_usb *usb, struct packet *pkt)
u32 trans_len;
bool td_done = false;

- td = remove_td_from_frame(usb->actual_frame);
+ td = fhci_remove_td_from_frame(usb->actual_frame);
td_pkt = td->pkt;
trans_len = pkt->len;
td->status = pkt->status;
@@ -119,7 +119,7 @@ void transaction_confirm(struct fhci_usb *usb, struct packet *pkt)
}

if (td_done)
- move_td_from_ed_to_done_list(usb, ed);
+ fhci_move_td_from_ed_to_done_list(usb, ed);
}

/*
@@ -127,7 +127,7 @@ void transaction_confirm(struct fhci_usb *usb, struct packet *pkt)
* This routine is called when disabling the USB port to flush all
* transmissions that are allready scheduled in the BDs
*/
-void flush_all_transmissions(struct fhci_usb *usb)
+void fhci_flush_all_transmissions(struct fhci_usb *usb)
{
u8 mode;
struct td *td;
@@ -135,13 +135,13 @@ void flush_all_transmissions(struct fhci_usb *usb)
mode = in_8(&usb->fhci->regs->usb_mod);
clrbits8(&usb->fhci->regs->usb_mod, USB_MODE_EN);

- flush_bds(usb);
+ fhci_flush_bds(usb);

- while ((td = peek_td_from_frame(usb->actual_frame)) != NULL) {
+ while ((td = fhci_peek_td_from_frame(usb->actual_frame)) != NULL) {
struct packet *pkt = td->pkt;

pkt->status = USB_TD_TX_ER_TIMEOUT;
- transaction_confirm(usb, pkt);
+ fhci_transaction_confirm(usb, pkt);
}

usb->actual_frame->frame_status = FRAME_END_TRANSMISSION;
@@ -207,7 +207,7 @@ static int add_packet(struct fhci_usb *usb, struct ed *ed, struct td *td)
if (usb->actual_frame->frame_status != FRAME_IS_PREPARED &&
(usb->actual_frame->frame_status & FRAME_END_TRANSMISSION ||
(fw_transaction_time + usb->sw_transaction_time >=
- 1000 - get_sof_timer_count(usb)))) {
+ 1000 - fhci_get_sof_timer_count(usb)))) {
fhci_dbg(usb->fhci, "not enough time in this frame\n");
return -1;
}
@@ -233,14 +233,14 @@ static int add_packet(struct fhci_usb *usb, struct ed *ed, struct td *td)
td->status = USB_TD_INPROGRESS;
/* update actual frame time object with the actual transmission */
usb->actual_frame->total_bytes += (len + PROTOCOL_OVERHEAD);
- add_td_to_frame(usb->actual_frame, td);
+ fhci_add_td_to_frame(usb->actual_frame, td);

if (usb->port_status != FHCI_PORT_FULL &&
usb->port_status != FHCI_PORT_LOW) {
pkt->status = USB_TD_TX_ER_TIMEOUT;
pkt->len = 0;
- transaction_confirm(usb, pkt);
- } else if (host_transaction(usb, pkt, td->type, ed->dev_addr,
+ fhci_transaction_confirm(usb, pkt);
+ } else if (fhci_host_transaction(usb, pkt, td->type, ed->dev_addr,
ed->ep_addr, ed->mode, ed->speed, td->toggle)) {
/* remove TD from actual frame */
list_del_init(&td->frame_lh);
@@ -295,7 +295,7 @@ static int scan_ed_list(struct fhci_usb *usb,
if (ed->state != FHCI_ED_OPER) {
if (ed->state == FHCI_ED_URB_DEL) {
td->status = USB_TD_OK;
- move_td_from_ed_to_done_list(usb, ed);
+ fhci_move_td_from_ed_to_done_list(usb, ed);
ed->state = FHCI_ED_SKIP;
}
continue;
@@ -321,7 +321,7 @@ static int scan_ed_list(struct fhci_usb *usb,
usb->max_bytes_per_frame) {
usb->actual_frame->frame_status =
FRAME_DATA_END_TRANSMISSION;
- push_dummy_bd(usb->ep0);
+ fhci_push_dummy_bd(usb->ep0);
ans = 0;
break;
}
@@ -344,7 +344,7 @@ static u32 rotate_frames(struct fhci_usb *usb)
if (!list_empty(&usb->actual_frame->tds_list)) {
if ((((in_be16(&fhci->pram->frame_num) & 0x07ff) -
usb->actual_frame->frame_num) & 0x7ff) > 5)
- flush_actual_frame(usb);
+ fhci_flush_actual_frame(usb);
else
return -EINVAL;
}
@@ -360,7 +360,7 @@ static u32 rotate_frames(struct fhci_usb *usb)
* This function schedule the USB transaction and will process the
* endpoint in the following order: iso, interrupt, control and bulk.
*/
-void schedule_transactions(struct fhci_usb *usb)
+void fhci_schedule_transactions(struct fhci_usb *usb)
{
int left = 1;

@@ -419,14 +419,14 @@ static void sof_interrupt(struct fhci_hcd *fhci)

gtm_set_exact_timer16(fhci->timer, usb->max_frame_usage, false);

- host_transmit_actual_frame(usb);
+ fhci_host_transmit_actual_frame(usb);
usb->actual_frame->frame_status = FRAME_IS_TRANSMITTED;

- schedule_transactions(usb);
+ fhci_schedule_transactions(usb);
}

/* Handles device disconnected interrupt on port */
-void device_disconnected_interrupt(struct fhci_hcd *fhci)
+void fhci_device_disconnected_interrupt(struct fhci_hcd *fhci)
{
struct fhci_usb *usb = fhci->usb_lld;

@@ -451,7 +451,7 @@ void device_disconnected_interrupt(struct fhci_hcd *fhci)
}

/* detect a new device connected on the USB port */
-void device_connected_interrupt(struct fhci_hcd *fhci)
+void fhci_device_connected_interrupt(struct fhci_hcd *fhci)
{

struct fhci_usb *usb = fhci->usb_lld;
@@ -481,7 +481,7 @@ void device_connected_interrupt(struct fhci_hcd *fhci)
USB_PORT_STAT_C_CONNECTION;
usb->max_bytes_per_frame =
(MAX_BYTES_PER_FRAME >> 3) - 7;
- usb_port_enable(usb);
+ fhci_port_enable(usb);
} else if (state == 2) {
ret = qe_usb_clock_set(fhci->fullspeed_clk, USB_CLOCK);
if (ret) {
@@ -499,7 +499,7 @@ void device_connected_interrupt(struct fhci_hcd *fhci)
usb->vroot_hub->port.wPortChange |=
USB_PORT_STAT_C_CONNECTION;
usb->max_bytes_per_frame = (MAX_BYTES_PER_FRAME - 15);
- usb_port_enable(usb);
+ fhci_port_enable(usb);
}
out:
fhci_usb_enable_interrupt(usb);
@@ -518,10 +518,10 @@ irqreturn_t fhci_frame_limit_timer_irq(int irq, void *_hcd)

if (usb->actual_frame->frame_status == FRAME_IS_TRANSMITTED) {
usb->actual_frame->frame_status = FRAME_TIMER_END_TRANSMISSION;
- push_dummy_bd(usb->ep0);
+ fhci_push_dummy_bd(usb->ep0);
}

- schedule_transactions(usb);
+ fhci_schedule_transactions(usb);

spin_unlock(&fhci->lock);

@@ -538,7 +538,7 @@ static void abort_transmission(struct fhci_usb *usb)
out_8(&usb->fhci->regs->usb_comm, USB_CMD_FLUSH_FIFO | EP_ZERO);
udelay(1000);
/* reset Tx BDs */
- flush_bds(usb);
+ fhci_flush_bds(usb);
/* issue restart Tx command */
qe_issue_cmd(QE_USB_RESTART_TX, QE_CR_SUBBLOCK_USB, EP_ZERO, 0);
fhci_dbg(usb->fhci, "<- %s\n", __func__);
@@ -566,7 +566,7 @@ irqreturn_t fhci_irq(struct usb_hcd *hcd)
if (usb_er & USB_E_RESET_MASK) {
if ((usb->port_status == FHCI_PORT_FULL) ||
(usb->port_status == FHCI_PORT_LOW)) {
- device_disconnected_interrupt(fhci);
+ fhci_device_disconnected_interrupt(fhci);
usb_er &= ~USB_E_IDLE_MASK;
} else if (usb->port_status == FHCI_PORT_WAITING) {
usb->port_status = FHCI_PORT_DISCONNECTING;
@@ -579,7 +579,7 @@ irqreturn_t fhci_irq(struct usb_hcd *hcd)
if (fhci_ioports_check_bus_state(fhci) == 1 &&
usb->port_status != FHCI_PORT_LOW &&
usb->port_status != FHCI_PORT_FULL)
- device_connected_interrupt(fhci);
+ fhci_device_connected_interrupt(fhci);
}
usb_er &= ~USB_E_RESET_MASK;
}
@@ -595,12 +595,12 @@ irqreturn_t fhci_irq(struct usb_hcd *hcd)
}

if (usb_er & USB_E_TXB_MASK) {
- tx_conf_interrupt(fhci->usb_lld);
+ fhci_tx_conf_interrupt(fhci->usb_lld);
usb_er &= ~USB_E_TXB_MASK;
}

if (usb_er & USB_E_TXE1_MASK) {
- tx_conf_interrupt(fhci->usb_lld);
+ fhci_tx_conf_interrupt(fhci->usb_lld);
usb_er &= ~USB_E_TXE1_MASK;
}

@@ -609,7 +609,7 @@ irqreturn_t fhci_irq(struct usb_hcd *hcd)
usb->port_status != FHCI_PORT_LOW &&
usb->port_status != FHCI_PORT_FULL) {
usb_er &= ~USB_E_RESET_MASK;
- device_connected_interrupt(fhci);
+ fhci_device_connected_interrupt(fhci);
} else if (usb->port_status ==
FHCI_PORT_DISCONNECTING) {
/* XXX usb->port_status = FHCI_PORT_WAITING; */
@@ -649,14 +649,14 @@ static void process_done_list(unsigned long data)
disable_irq(fhci_to_hcd(fhci)->irq);
spin_lock(&fhci->lock);

- td = remove_td_from_done_list(fhci->hc_list);
+ td = fhci_remove_td_from_done_list(fhci->hc_list);
while (td != NULL) {
urb = td->urb;
urb_priv = urb->hcpriv;
ed = td->ed;

/* update URB's length and status from TD */
- done_td(urb, td);
+ fhci_done_td(urb, td);
urb_priv->tds_cnt++;

/*
@@ -666,19 +666,19 @@ static void process_done_list(unsigned long data)
* (real work done in a SOF intr, by process_del_list)
*/
if (urb_priv->tds_cnt == urb_priv->num_of_tds) {
- urb_complete_free(fhci, urb);
+ fhci_urb_complete_free(fhci, urb);
} else if (urb_priv->state == URB_DEL &&
ed->state == FHCI_ED_SKIP) {
- del_ed_list(fhci, ed);
+ fhci_del_ed_list(fhci, ed);
ed->state = FHCI_ED_OPER;
} else if (ed->state == FHCI_ED_HALTED) {
urb_priv->state = URB_DEL;
ed->state = FHCI_ED_URB_DEL;
- del_ed_list(fhci, ed);
+ fhci_del_ed_list(fhci, ed);
ed->state = FHCI_ED_OPER;
}

- td = remove_td_from_done_list(fhci->hc_list);
+ td = fhci_remove_td_from_done_list(fhci->hc_list);
}

spin_unlock(&fhci->lock);
@@ -689,7 +689,7 @@ static void process_done_list(unsigned long data)
DECLARE_TASKLET(fhci_tasklet, process_done_list, 0);

/* transfer complted callback */
-u32 transfer_confirm_callback(struct fhci_hcd *fhci)
+u32 fhci_transfer_confirm_callback(struct fhci_hcd *fhci)
{
if (!fhci->process_done_task->state)
tasklet_schedule(fhci->process_done_task);
@@ -703,7 +703,7 @@ u32 transfer_confirm_callback(struct fhci_hcd *fhci)
* ep USB Host endpoint data structure
* urb USB request block data structure
*/
-void queue_urb(struct fhci_hcd *fhci, struct urb *urb)
+void fhci_queue_urb(struct fhci_hcd *fhci, struct urb *urb)
{
struct ed *ed = urb->ep->hcpriv;
struct urb_priv *urb_priv = urb->hcpriv;
@@ -715,7 +715,7 @@ void queue_urb(struct fhci_hcd *fhci, struct urb *urb)
u16 cnt = 0;

if (ed == NULL) {
- ed = get_empty_ed(fhci);
+ ed = fhci_get_empty_ed(fhci);
ed->dev_addr = usb_pipedevice(urb->pipe);
ed->ep_addr = usb_pipeendpoint(urb->pipe);
switch (usb_pipetype(urb->pipe)) {
@@ -777,7 +777,7 @@ void queue_urb(struct fhci_hcd *fhci, struct urb *urb)
usb_pipeout(urb->pipe))) == 0))
urb_state = US_BULK0;
while (data_len > 4096) {
- td = td_fill(fhci, urb, urb_priv, ed, cnt,
+ td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt,
usb_pipeout(urb->pipe) ? FHCI_TA_OUT :
FHCI_TA_IN,
cnt ? USB_TD_TOGGLE_CARRY :
@@ -788,7 +788,7 @@ void queue_urb(struct fhci_hcd *fhci, struct urb *urb)
cnt++;
}

- td = td_fill(fhci, urb, urb_priv, ed, cnt,
+ td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt,
usb_pipeout(urb->pipe) ? FHCI_TA_OUT : FHCI_TA_IN,
cnt ? USB_TD_TOGGLE_CARRY : toggle,
data, data_len, 0, 0, true);
@@ -796,7 +796,7 @@ void queue_urb(struct fhci_hcd *fhci, struct urb *urb)

if (urb->transfer_flags & URB_ZERO_PACKET &&
cnt < urb_priv->num_of_tds) {
- td = td_fill(fhci, urb, urb_priv, ed, cnt,
+ td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt,
usb_pipeout(urb->pipe) ? FHCI_TA_OUT :
FHCI_TA_IN,
USB_TD_TOGGLE_CARRY, NULL, 0, 0, 0, true);
@@ -805,7 +805,7 @@ void queue_urb(struct fhci_hcd *fhci, struct urb *urb)
break;
case FHCI_TF_INTR:
urb->start_frame = get_frame_num(fhci) + 1;
- td = td_fill(fhci, urb, urb_priv, ed, cnt++,
+ td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
usb_pipeout(urb->pipe) ? FHCI_TA_OUT : FHCI_TA_IN,
USB_TD_TOGGLE_DATA0, data, data_len,
urb->interval, urb->start_frame, true);
@@ -814,17 +814,17 @@ void queue_urb(struct fhci_hcd *fhci, struct urb *urb)
ed->dev_addr = usb_pipedevice(urb->pipe);
ed->max_pkt_size = usb_maxpacket(urb->dev, urb->pipe,
usb_pipeout(urb->pipe));
- td = td_fill(fhci, urb, urb_priv, ed, cnt++, FHCI_TA_SETUP,
+ td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++, FHCI_TA_SETUP,
USB_TD_TOGGLE_DATA0, urb->setup_packet, 8, 0, 0, true);

if (data_len > 0) {
- td = td_fill(fhci, urb, urb_priv, ed, cnt++,
+ td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
usb_pipeout(urb->pipe) ? FHCI_TA_OUT :
FHCI_TA_IN,
USB_TD_TOGGLE_DATA1, data, data_len, 0, 0,
true);
}
- td = td_fill(fhci, urb, urb_priv, ed, cnt++,
+ td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++,
usb_pipeout(urb->pipe) ? FHCI_TA_IN : FHCI_TA_OUT,
USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true);
urb_state = US_CTRL_SETUP;
@@ -840,7 +840,7 @@ void queue_urb(struct fhci_hcd *fhci, struct urb *urb)
*/
frame += cnt * urb->interval;
frame &= 0x07ff;
- td = td_fill(fhci, urb, urb_priv, ed, cnt,
+ td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt,
usb_pipeout(urb->pipe) ? FHCI_TA_OUT :
FHCI_TA_IN,
USB_TD_TOGGLE_DATA0,
@@ -883,6 +883,6 @@ void queue_urb(struct fhci_hcd *fhci, struct urb *urb)
}
}

- add_tds_to_ed(ed, urb_priv->tds, urb_priv->num_of_tds);
+ fhci_add_tds_to_ed(ed, urb_priv->tds, urb_priv->num_of_tds);
fhci->active_urbs++;
}
diff --git a/drivers/usb/host/fhci-tds.c b/drivers/usb/host/fhci-tds.c
index 90e74ca..b403322 100644
--- a/drivers/usb/host/fhci-tds.c
+++ b/drivers/usb/host/fhci-tds.c
@@ -82,7 +82,7 @@ static struct usb_td __iomem *next_bd(struct usb_td __iomem *base,
return ++td;
}

-void push_dummy_bd(struct endpoint *ep)
+void fhci_push_dummy_bd(struct endpoint *ep)
{
if (ep->already_pushed_dummy_bd == false) {
u16 td_status = in_be16(&ep->empty_td->status);
@@ -95,7 +95,7 @@ void push_dummy_bd(struct endpoint *ep)
}

/* destroy an USB endpoint */
-void endpoint_zero_free(struct fhci_usb *usb)
+void fhci_ep0_free(struct fhci_usb *usb)
{
struct endpoint *ep;
int size;
@@ -148,7 +148,7 @@ void endpoint_zero_free(struct fhci_usb *usb)
* data_mem The data memory partition(BUS)
* ring_len TD ring length
*/
-u32 create_endpoint(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
+u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
u32 ring_len)
{
struct endpoint *ep;
@@ -229,7 +229,7 @@ u32 create_endpoint(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,

return 0;
err:
- endpoint_zero_free(usb);
+ fhci_ep0_free(usb);
kfree(ep);
fhci_err(usb->fhci, "no memory for the %s\n", err_for);
return -ENOMEM;
@@ -243,9 +243,8 @@ err:
* ep A pointer to the endpoint structre
* data_mem The data memory partition(BUS)
*/
-void init_endpoint_registers(struct fhci_usb *usb,
- struct endpoint *ep,
- enum fhci_mem_alloc data_mem)
+void fhci_init_ep_registers(struct fhci_usb *usb, struct endpoint *ep,
+ enum fhci_mem_alloc data_mem)
{
u8 rt;

@@ -277,9 +276,9 @@ void init_endpoint_registers(struct fhci_usb *usb,
* confirmation about the submitted frames. Otherwise, the routine is
* called frome the interrupt service routine during the Tx interrupt.
* In that case the application is informed by calling the application
- * specific 'transaction_confirm' routine
+ * specific 'fhci_transaction_confirm' routine
*/
-static void td_transaction_confirm(struct fhci_usb *usb)
+static void fhci_td_transaction_confirm(struct fhci_usb *usb)
{
struct endpoint *ep = usb->ep0;
struct packet *pkt;
@@ -361,7 +360,7 @@ static void td_transaction_confirm(struct fhci_usb *usb)
else
pkt->len = td_length;

- transaction_confirm(usb, pkt);
+ fhci_transaction_confirm(usb, pkt);
}
}

@@ -379,13 +378,13 @@ static void td_transaction_confirm(struct fhci_usb *usb)
* dest_speed USB speed - Low speed or FULL speed
* data_toggle Data sequence toggle - 0 or 1
*/
-u32 host_transaction(struct fhci_usb *usb,
- struct packet *pkt,
- enum fhci_ta_type trans_type,
- u8 dest_addr,
- u8 dest_ep,
- enum fhci_tf_mode trans_mode,
- enum fhci_speed dest_speed, u8 data_toggle)
+u32 fhci_host_transaction(struct fhci_usb *usb,
+ struct packet *pkt,
+ enum fhci_ta_type trans_type,
+ u8 dest_addr,
+ u8 dest_ep,
+ enum fhci_tf_mode trans_mode,
+ enum fhci_speed dest_speed, u8 data_toggle)
{
struct endpoint *ep = usb->ep0;
struct usb_td __iomem *td;
@@ -470,7 +469,7 @@ u32 host_transaction(struct fhci_usb *usb,
}

/* Reset the Tx BD ring */
-void flush_bds(struct fhci_usb *usb)
+void fhci_flush_bds(struct fhci_usb *usb)
{
u16 extra_data;
u16 td_status;
@@ -497,7 +496,7 @@ void flush_bds(struct fhci_usb *usb)
td++;
}

- td_transaction_confirm(usb);
+ fhci_td_transaction_confirm(usb);

td = ep->td_base;
do {
@@ -525,7 +524,7 @@ void flush_bds(struct fhci_usb *usb)
* This routine is called when something wrong with the controller and
* we want to get rid of the actual frame and start again next frame
*/
-void flush_actual_frame(struct fhci_usb *usb)
+void fhci_flush_actual_frame(struct fhci_usb *usb)
{
u8 mode;
u16 tb_ptr;
@@ -560,7 +559,7 @@ void flush_actual_frame(struct fhci_usb *usb)
extra_data = in_be16(&td->extra);
} while ((td_status & TD_R) || buf_ptr);

- td_transaction_confirm(usb);
+ fhci_td_transaction_confirm(usb);

out_be16(&ep->ep_pram_ptr->tx_bd_ptr,
in_be16(&ep->ep_pram_ptr->tx_base));
@@ -578,21 +577,21 @@ void flush_actual_frame(struct fhci_usb *usb)
}

/* handles Tx confirm and Tx error interrupt */
-void tx_conf_interrupt(struct fhci_usb *usb)
+void fhci_tx_conf_interrupt(struct fhci_usb *usb)
{
- td_transaction_confirm(usb);
+ fhci_td_transaction_confirm(usb);

/*
* Schedule another transaction to this frame only if we have
* already confirmed all transaction in the frame.
*/
- if (((get_sof_timer_count(usb) < usb->max_frame_usage) ||
+ if (((fhci_get_sof_timer_count(usb) < usb->max_frame_usage) ||
(usb->actual_frame->frame_status & FRAME_END_TRANSMISSION)) &&
(list_empty(&usb->actual_frame->tds_list)))
- schedule_transactions(usb);
+ fhci_schedule_transactions(usb);
}

-void host_transmit_actual_frame(struct fhci_usb *usb)
+void fhci_host_transmit_actual_frame(struct fhci_usb *usb)
{
u16 tb_ptr;
u16 td_status;
diff --git a/drivers/usb/host/fhci.h b/drivers/usb/host/fhci.h
index d1b6bbe..7116284 100644
--- a/drivers/usb/host/fhci.h
+++ b/drivers/usb/host/fhci.h
@@ -524,71 +524,71 @@ static inline void *cq_get(struct kfifo *kfifo)
/* fhci-hcd.c */
void fhci_start_sof_timer(struct fhci_hcd *fhci);
void fhci_stop_sof_timer(struct fhci_hcd *fhci);
-u16 get_sof_timer_count(struct fhci_usb *usb);
+u16 fhci_get_sof_timer_count(struct fhci_usb *usb);
void fhci_usb_enable_interrupt(struct fhci_usb *usb);
void fhci_usb_disable_interrupt(struct fhci_usb *usb);
int fhci_ioports_check_bus_state(struct fhci_hcd *fhci);

/* fhci-mem.c */
-void recycle_empty_td(struct fhci_hcd *fhci, struct td *td);
-void recycle_empty_ed(struct fhci_hcd *fhci, struct ed *ed);
-struct ed *get_empty_ed(struct fhci_hcd *fhci);
-struct td *td_fill(struct fhci_hcd *fhci, struct urb *urb,
- struct urb_priv *urb_priv, struct ed *ed, u16 index,
- enum fhci_ta_type type, int toggle, u8 *data, u32 len,
- u16 interval, u16 start_frame, bool ioc);
-void add_tds_to_ed(struct ed *ed, struct td **td_list, int number);
+void fhci_recycle_empty_td(struct fhci_hcd *fhci, struct td *td);
+void fhci_recycle_empty_ed(struct fhci_hcd *fhci, struct ed *ed);
+struct ed *fhci_get_empty_ed(struct fhci_hcd *fhci);
+struct td *fhci_td_fill(struct fhci_hcd *fhci, struct urb *urb,
+ struct urb_priv *urb_priv, struct ed *ed, u16 index,
+ enum fhci_ta_type type, int toggle, u8 *data, u32 len,
+ u16 interval, u16 start_frame, bool ioc);
+void fhci_add_tds_to_ed(struct ed *ed, struct td **td_list, int number);

/* fhci-hub.c */
-void config_transceiver(struct fhci_hcd *fhci,
+void fhci_config_transceiver(struct fhci_hcd *fhci,
enum fhci_port_status status);
-void usb_port_disable(struct fhci_hcd *fhci);
-void usb_port_enable(void *lld);
-void io_port_generate_reset(struct fhci_hcd *fhci);
-void usb_port_reset(void *lld);
+void fhci_port_disable(struct fhci_hcd *fhci);
+void fhci_port_enable(void *lld);
+void fhci_io_port_generate_reset(struct fhci_hcd *fhci);
+void fhci_port_reset(void *lld);
int fhci_hub_status_data(struct usb_hcd *hcd, char *buf);
int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
u16 wIndex, char *buf, u16 wLength);

/* fhci-tds.c */
-void flush_bds(struct fhci_usb *usb);
-void flush_actual_frame(struct fhci_usb *usb);
-u32 host_transaction(struct fhci_usb *usb,
- struct packet *pkt, enum fhci_ta_type trans_type,
- u8 dest_addr, u8 dest_ep, enum fhci_tf_mode trans_mode,
- enum fhci_speed dest_speed, u8 data_toggle);
-void host_transmit_actual_frame(struct fhci_usb *usb);
-void tx_conf_interrupt(struct fhci_usb *usb);
-void push_dummy_bd(struct endpoint *ep);
-u32 create_endpoint(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
- u32 ring_len);
-void init_endpoint_registers(struct fhci_usb *usb,
- struct endpoint *ep,
- enum fhci_mem_alloc data_mem);
-void endpoint_zero_free(struct fhci_usb *usb);
+void fhci_flush_bds(struct fhci_usb *usb);
+void fhci_flush_actual_frame(struct fhci_usb *usb);
+u32 fhci_host_transaction(struct fhci_usb *usb, struct packet *pkt,
+ enum fhci_ta_type trans_type, u8 dest_addr,
+ u8 dest_ep, enum fhci_tf_mode trans_mode,
+ enum fhci_speed dest_speed, u8 data_toggle);
+void fhci_host_transmit_actual_frame(struct fhci_usb *usb);
+void fhci_tx_conf_interrupt(struct fhci_usb *usb);
+void fhci_push_dummy_bd(struct endpoint *ep);
+u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
+ u32 ring_len);
+void fhci_init_ep_registers(struct fhci_usb *usb,
+ struct endpoint *ep,
+ enum fhci_mem_alloc data_mem);
+void fhci_ep0_free(struct fhci_usb *usb);

/* fhci-sched.c */
extern struct tasklet_struct fhci_tasklet;
-void transaction_confirm(struct fhci_usb *usb, struct packet *pkt);
-void flush_all_transmissions(struct fhci_usb *usb);
-void schedule_transactions(struct fhci_usb *usb);
-void device_connected_interrupt(struct fhci_hcd *fhci);
-void device_disconnected_interrupt(struct fhci_hcd *fhci);
-void queue_urb(struct fhci_hcd *fhci, struct urb *urb);
-u32 transfer_confirm_callback(struct fhci_hcd *fhci);
+void fhci_transaction_confirm(struct fhci_usb *usb, struct packet *pkt);
+void fhci_flush_all_transmissions(struct fhci_usb *usb);
+void fhci_schedule_transactions(struct fhci_usb *usb);
+void fhci_device_connected_interrupt(struct fhci_hcd *fhci);
+void fhci_device_disconnected_interrupt(struct fhci_hcd *fhci);
+void fhci_queue_urb(struct fhci_hcd *fhci, struct urb *urb);
+u32 fhci_transfer_confirm_callback(struct fhci_hcd *fhci);
irqreturn_t fhci_irq(struct usb_hcd *hcd);
irqreturn_t fhci_frame_limit_timer_irq(int irq, void *_hcd);

/* fhci-q.h */
-void urb_complete_free(struct fhci_hcd *fhci, struct urb *urb);
-struct td *remove_td_from_ed(struct ed *ed);
-struct td *remove_td_from_frame(struct fhci_time_frame *frame);
-void move_td_from_ed_to_done_list(struct fhci_usb *usb, struct ed *ed);
-struct td *peek_td_from_frame(struct fhci_time_frame *frame);
-void add_td_to_frame(struct fhci_time_frame *frame, struct td *td);
-struct td *remove_td_from_done_list(struct fhci_controller_list *p_list);
-void done_td(struct urb *urb, struct td *td);
-void del_ed_list(struct fhci_hcd *fhci, struct ed *ed);
+void fhci_urb_complete_free(struct fhci_hcd *fhci, struct urb *urb);
+struct td *fhci_remove_td_from_ed(struct ed *ed);
+struct td *fhci_remove_td_from_frame(struct fhci_time_frame *frame);
+void fhci_move_td_from_ed_to_done_list(struct fhci_usb *usb, struct ed *ed);
+struct td *fhci_peek_td_from_frame(struct fhci_time_frame *frame);
+void fhci_add_td_to_frame(struct fhci_time_frame *frame, struct td *td);
+struct td *fhci_remove_td_from_done_list(struct fhci_controller_list *p_list);
+void fhci_done_td(struct urb *urb, struct td *td);
+void fhci_del_ed_list(struct fhci_hcd *fhci, struct ed *ed);

#ifdef CONFIG_FHCI_DEBUG

--
1.5.6.5