mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-05 18:39:59 +00:00
![Lee Jones](/assets/img/avatar_default.png)
Neither have been used since the driver's inception in 2009. Fixes the following W=1 kernel build warning(s): drivers/usb/host/fhci-tds.c: In function ‘fhci_flush_bds’: drivers/usb/host/fhci-tds.c:472:6: warning: variable ‘buf’ set but not used [-Wunused-but-set-variable] 472 | u32 buf; | ^~~ drivers/usb/host/fhci-tds.c:470:6: warning: variable ‘extra_data’ set but not used [-Wunused-but-set-variable] 470 | u16 extra_data; | ^~~~~~~~~~ drivers/usb/host/fhci-tds.c: In function ‘fhci_flush_actual_frame’: drivers/usb/host/fhci-tds.c:527:6: warning: variable ‘extra_data’ set but not used [-Wunused-but-set-variable] 527 | u16 extra_data; | ^~~~~~~~~~ Cc: Shlomi Gridish <gridish@freescale.com> Cc: Jerry Huang <Chang-Ming.Huang@freescale.com> Cc: Peter Barada <peterb@logicpd.com> Cc: Anton Vorontsov <avorontsov@ru.mvista.com> Signed-off-by: Lee Jones <lee.jones@linaro.org> Link: https://lore.kernel.org/r/20200706133341.476881-31-lee.jones@linaro.org Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
619 lines
16 KiB
C
619 lines
16 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Freescale QUICC Engine USB Host Controller Driver
|
|
*
|
|
* Copyright (c) Freescale Semicondutor, Inc. 2006.
|
|
* Shlomi Gridish <gridish@freescale.com>
|
|
* Jerry Huang <Chang-Ming.Huang@freescale.com>
|
|
* Copyright (c) Logic Product Development, Inc. 2007
|
|
* Peter Barada <peterb@logicpd.com>
|
|
* Copyright (c) MontaVista Software, Inc. 2008.
|
|
* Anton Vorontsov <avorontsov@ru.mvista.com>
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/types.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/list.h>
|
|
#include <linux/io.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/usb/hcd.h>
|
|
#include "fhci.h"
|
|
|
|
#define DUMMY_BD_BUFFER 0xdeadbeef
|
|
#define DUMMY2_BD_BUFFER 0xbaadf00d
|
|
|
|
/* Transaction Descriptors bits */
|
|
#define TD_R 0x8000 /* ready bit */
|
|
#define TD_W 0x2000 /* wrap bit */
|
|
#define TD_I 0x1000 /* interrupt on completion */
|
|
#define TD_L 0x0800 /* last */
|
|
#define TD_TC 0x0400 /* transmit CRC */
|
|
#define TD_CNF 0x0200 /* CNF - Must be always 1 */
|
|
#define TD_LSP 0x0100 /* Low-speed transaction */
|
|
#define TD_PID 0x00c0 /* packet id */
|
|
#define TD_RXER 0x0020 /* Rx error or not */
|
|
|
|
#define TD_NAK 0x0010 /* No ack. */
|
|
#define TD_STAL 0x0008 /* Stall received */
|
|
#define TD_TO 0x0004 /* time out */
|
|
#define TD_UN 0x0002 /* underrun */
|
|
#define TD_NO 0x0010 /* Rx Non Octet Aligned Packet */
|
|
#define TD_AB 0x0008 /* Frame Aborted */
|
|
#define TD_CR 0x0004 /* CRC Error */
|
|
#define TD_OV 0x0002 /* Overrun */
|
|
#define TD_BOV 0x0001 /* Buffer Overrun */
|
|
|
|
#define TD_ERRORS (TD_NAK | TD_STAL | TD_TO | TD_UN | \
|
|
TD_NO | TD_AB | TD_CR | TD_OV | TD_BOV)
|
|
|
|
#define TD_PID_DATA0 0x0080 /* Data 0 toggle */
|
|
#define TD_PID_DATA1 0x00c0 /* Data 1 toggle */
|
|
#define TD_PID_TOGGLE 0x00c0 /* Data 0/1 toggle mask */
|
|
|
|
#define TD_TOK_SETUP 0x0000
|
|
#define TD_TOK_OUT 0x4000
|
|
#define TD_TOK_IN 0x8000
|
|
#define TD_ISO 0x1000
|
|
#define TD_ENDP 0x0780
|
|
#define TD_ADDR 0x007f
|
|
|
|
#define TD_ENDP_SHIFT 7
|
|
|
|
struct usb_td {
|
|
__be16 status;
|
|
__be16 length;
|
|
__be32 buf_ptr;
|
|
__be16 extra;
|
|
__be16 reserved;
|
|
};
|
|
|
|
static struct usb_td __iomem *next_bd(struct usb_td __iomem *base,
|
|
struct usb_td __iomem *td,
|
|
u16 status)
|
|
{
|
|
if (status & TD_W)
|
|
return base;
|
|
else
|
|
return ++td;
|
|
}
|
|
|
|
void fhci_push_dummy_bd(struct endpoint *ep)
|
|
{
|
|
if (!ep->already_pushed_dummy_bd) {
|
|
u16 td_status = in_be16(&ep->empty_td->status);
|
|
|
|
out_be32(&ep->empty_td->buf_ptr, DUMMY_BD_BUFFER);
|
|
/* get the next TD in the ring */
|
|
ep->empty_td = next_bd(ep->td_base, ep->empty_td, td_status);
|
|
ep->already_pushed_dummy_bd = true;
|
|
}
|
|
}
|
|
|
|
/* destroy an USB endpoint */
|
|
void fhci_ep0_free(struct fhci_usb *usb)
|
|
{
|
|
struct endpoint *ep;
|
|
int size;
|
|
|
|
ep = usb->ep0;
|
|
if (ep) {
|
|
if (ep->td_base)
|
|
cpm_muram_free(cpm_muram_offset(ep->td_base));
|
|
|
|
if (kfifo_initialized(&ep->conf_frame_Q)) {
|
|
size = cq_howmany(&ep->conf_frame_Q);
|
|
for (; size; size--) {
|
|
struct packet *pkt = cq_get(&ep->conf_frame_Q);
|
|
|
|
kfree(pkt);
|
|
}
|
|
cq_delete(&ep->conf_frame_Q);
|
|
}
|
|
|
|
if (kfifo_initialized(&ep->empty_frame_Q)) {
|
|
size = cq_howmany(&ep->empty_frame_Q);
|
|
for (; size; size--) {
|
|
struct packet *pkt = cq_get(&ep->empty_frame_Q);
|
|
|
|
kfree(pkt);
|
|
}
|
|
cq_delete(&ep->empty_frame_Q);
|
|
}
|
|
|
|
if (kfifo_initialized(&ep->dummy_packets_Q)) {
|
|
size = cq_howmany(&ep->dummy_packets_Q);
|
|
for (; size; size--) {
|
|
u8 *buff = cq_get(&ep->dummy_packets_Q);
|
|
|
|
kfree(buff);
|
|
}
|
|
cq_delete(&ep->dummy_packets_Q);
|
|
}
|
|
|
|
kfree(ep);
|
|
usb->ep0 = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* create the endpoint structure
|
|
*
|
|
* arguments:
|
|
* usb A pointer to the data structure of the USB
|
|
* data_mem The data memory partition(BUS)
|
|
* ring_len TD ring length
|
|
*/
|
|
u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
|
|
u32 ring_len)
|
|
{
|
|
struct endpoint *ep;
|
|
struct usb_td __iomem *td;
|
|
unsigned long ep_offset;
|
|
char *err_for = "endpoint PRAM";
|
|
int ep_mem_size;
|
|
u32 i;
|
|
|
|
/* we need at least 3 TDs in the ring */
|
|
if (!(ring_len > 2)) {
|
|
fhci_err(usb->fhci, "illegal TD ring length parameters\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
ep = kzalloc(sizeof(*ep), GFP_KERNEL);
|
|
if (!ep)
|
|
return -ENOMEM;
|
|
|
|
ep_mem_size = ring_len * sizeof(*td) + sizeof(struct fhci_ep_pram);
|
|
ep_offset = cpm_muram_alloc(ep_mem_size, 32);
|
|
if (IS_ERR_VALUE(ep_offset))
|
|
goto err;
|
|
ep->td_base = cpm_muram_addr(ep_offset);
|
|
|
|
/* zero all queue pointers */
|
|
if (cq_new(&ep->conf_frame_Q, ring_len + 2) ||
|
|
cq_new(&ep->empty_frame_Q, ring_len + 2) ||
|
|
cq_new(&ep->dummy_packets_Q, ring_len + 2)) {
|
|
err_for = "frame_queues";
|
|
goto err;
|
|
}
|
|
|
|
for (i = 0; i < (ring_len + 1); i++) {
|
|
struct packet *pkt;
|
|
u8 *buff;
|
|
|
|
pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
|
|
if (!pkt) {
|
|
err_for = "frame";
|
|
goto err;
|
|
}
|
|
|
|
buff = kmalloc_array(1028, sizeof(*buff), GFP_KERNEL);
|
|
if (!buff) {
|
|
kfree(pkt);
|
|
err_for = "buffer";
|
|
goto err;
|
|
}
|
|
cq_put(&ep->empty_frame_Q, pkt);
|
|
cq_put(&ep->dummy_packets_Q, buff);
|
|
}
|
|
|
|
/* we put the endpoint parameter RAM right behind the TD ring */
|
|
ep->ep_pram_ptr = (void __iomem *)ep->td_base + sizeof(*td) * ring_len;
|
|
|
|
ep->conf_td = ep->td_base;
|
|
ep->empty_td = ep->td_base;
|
|
|
|
ep->already_pushed_dummy_bd = false;
|
|
|
|
/* initialize tds */
|
|
td = ep->td_base;
|
|
for (i = 0; i < ring_len; i++) {
|
|
out_be32(&td->buf_ptr, 0);
|
|
out_be16(&td->status, 0);
|
|
out_be16(&td->length, 0);
|
|
out_be16(&td->extra, 0);
|
|
td++;
|
|
}
|
|
td--;
|
|
out_be16(&td->status, TD_W); /* for last TD set Wrap bit */
|
|
out_be16(&td->length, 0);
|
|
|
|
/* endpoint structure has been created */
|
|
usb->ep0 = ep;
|
|
|
|
return 0;
|
|
err:
|
|
fhci_ep0_free(usb);
|
|
kfree(ep);
|
|
fhci_err(usb->fhci, "no memory for the %s\n", err_for);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/*
|
|
* initialize the endpoint register according to the given parameters
|
|
*
|
|
* artuments:
|
|
* usb A pointer to the data strucutre of the USB
|
|
* ep A pointer to the endpoint structre
|
|
* data_mem The data memory partition(BUS)
|
|
*/
|
|
void fhci_init_ep_registers(struct fhci_usb *usb, struct endpoint *ep,
|
|
enum fhci_mem_alloc data_mem)
|
|
{
|
|
u8 rt;
|
|
|
|
/* set the endpoint registers according to the endpoint */
|
|
out_be16(&usb->fhci->regs->usb_usep[0],
|
|
USB_TRANS_CTR | USB_EP_MF | USB_EP_RTE);
|
|
out_be16(&usb->fhci->pram->ep_ptr[0],
|
|
cpm_muram_offset(ep->ep_pram_ptr));
|
|
|
|
rt = (BUS_MODE_BO_BE | BUS_MODE_GBL);
|
|
#ifdef MULTI_DATA_BUS
|
|
if (data_mem == MEM_SECONDARY)
|
|
rt |= BUS_MODE_DTB;
|
|
#endif
|
|
out_8(&ep->ep_pram_ptr->rx_func_code, rt);
|
|
out_8(&ep->ep_pram_ptr->tx_func_code, rt);
|
|
out_be16(&ep->ep_pram_ptr->rx_buff_len, 1028);
|
|
out_be16(&ep->ep_pram_ptr->rx_base, 0);
|
|
out_be16(&ep->ep_pram_ptr->tx_base, cpm_muram_offset(ep->td_base));
|
|
out_be16(&ep->ep_pram_ptr->rx_bd_ptr, 0);
|
|
out_be16(&ep->ep_pram_ptr->tx_bd_ptr, cpm_muram_offset(ep->td_base));
|
|
out_be32(&ep->ep_pram_ptr->tx_state, 0);
|
|
}
|
|
|
|
/*
|
|
* Collect the submitted frames and inform the application about them
|
|
* It is also preparing the TDs for new frames. If the Tx interrupts
|
|
* are disabled, the application should call that routine to get
|
|
* confirmation about the submitted frames. Otherwise, the routine is
|
|
* called from the interrupt service routine during the Tx interrupt.
|
|
* In that case the application is informed by calling the application
|
|
* specific 'fhci_transaction_confirm' routine
|
|
*/
|
|
static void fhci_td_transaction_confirm(struct fhci_usb *usb)
|
|
{
|
|
struct endpoint *ep = usb->ep0;
|
|
struct packet *pkt;
|
|
struct usb_td __iomem *td;
|
|
u16 extra_data;
|
|
u16 td_status;
|
|
u16 td_length;
|
|
u32 buf;
|
|
|
|
/*
|
|
* collect transmitted BDs from the chip. The routine clears all BDs
|
|
* with R bit = 0 and the pointer to data buffer is not NULL, that is
|
|
* BDs which point to the transmitted data buffer
|
|
*/
|
|
while (1) {
|
|
td = ep->conf_td;
|
|
td_status = in_be16(&td->status);
|
|
td_length = in_be16(&td->length);
|
|
buf = in_be32(&td->buf_ptr);
|
|
extra_data = in_be16(&td->extra);
|
|
|
|
/* check if the TD is empty */
|
|
if (!(!(td_status & TD_R) && ((td_status & ~TD_W) || buf)))
|
|
break;
|
|
/* check if it is a dummy buffer */
|
|
else if ((buf == DUMMY_BD_BUFFER) && !(td_status & ~TD_W))
|
|
break;
|
|
|
|
/* mark TD as empty */
|
|
clrbits16(&td->status, ~TD_W);
|
|
out_be16(&td->length, 0);
|
|
out_be32(&td->buf_ptr, 0);
|
|
out_be16(&td->extra, 0);
|
|
/* advance the TD pointer */
|
|
ep->conf_td = next_bd(ep->td_base, ep->conf_td, td_status);
|
|
|
|
/* check if it is a dummy buffer(type2) */
|
|
if ((buf == DUMMY2_BD_BUFFER) && !(td_status & ~TD_W))
|
|
continue;
|
|
|
|
pkt = cq_get(&ep->conf_frame_Q);
|
|
if (!pkt)
|
|
fhci_err(usb->fhci, "no frame to confirm\n");
|
|
|
|
if (td_status & TD_ERRORS) {
|
|
if (td_status & TD_RXER) {
|
|
if (td_status & TD_CR)
|
|
pkt->status = USB_TD_RX_ER_CRC;
|
|
else if (td_status & TD_AB)
|
|
pkt->status = USB_TD_RX_ER_BITSTUFF;
|
|
else if (td_status & TD_OV)
|
|
pkt->status = USB_TD_RX_ER_OVERUN;
|
|
else if (td_status & TD_BOV)
|
|
pkt->status = USB_TD_RX_DATA_OVERUN;
|
|
else if (td_status & TD_NO)
|
|
pkt->status = USB_TD_RX_ER_NONOCT;
|
|
else
|
|
fhci_err(usb->fhci, "illegal error "
|
|
"occurred\n");
|
|
} else if (td_status & TD_NAK)
|
|
pkt->status = USB_TD_TX_ER_NAK;
|
|
else if (td_status & TD_TO)
|
|
pkt->status = USB_TD_TX_ER_TIMEOUT;
|
|
else if (td_status & TD_UN)
|
|
pkt->status = USB_TD_TX_ER_UNDERUN;
|
|
else if (td_status & TD_STAL)
|
|
pkt->status = USB_TD_TX_ER_STALL;
|
|
else
|
|
fhci_err(usb->fhci, "illegal error occurred\n");
|
|
} else if ((extra_data & TD_TOK_IN) &&
|
|
pkt->len > td_length - CRC_SIZE) {
|
|
pkt->status = USB_TD_RX_DATA_UNDERUN;
|
|
}
|
|
|
|
if (extra_data & TD_TOK_IN)
|
|
pkt->len = td_length - CRC_SIZE;
|
|
else if (pkt->info & PKT_ZLP)
|
|
pkt->len = 0;
|
|
else
|
|
pkt->len = td_length;
|
|
|
|
fhci_transaction_confirm(usb, pkt);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Submitting a data frame to a specified endpoint of a USB device
|
|
* The frame is put in the driver's transmit queue for this endpoint
|
|
*
|
|
* Arguments:
|
|
* usb A pointer to the USB structure
|
|
* pkt A pointer to the user frame structure
|
|
* trans_type Transaction tyep - IN,OUT or SETUP
|
|
* dest_addr Device address - 0~127
|
|
* dest_ep Endpoint number of the device - 0~16
|
|
* trans_mode Pipe type - ISO,Interrupt,bulk or control
|
|
* dest_speed USB speed - Low speed or FULL speed
|
|
* data_toggle Data sequence toggle - 0 or 1
|
|
*/
|
|
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;
|
|
u16 extra_data;
|
|
u16 td_status;
|
|
|
|
fhci_usb_disable_interrupt(usb);
|
|
/* start from the next BD that should be filled */
|
|
td = ep->empty_td;
|
|
td_status = in_be16(&td->status);
|
|
|
|
if (td_status & TD_R && in_be16(&td->length)) {
|
|
/* if the TD is not free */
|
|
fhci_usb_enable_interrupt(usb);
|
|
return -1;
|
|
}
|
|
|
|
/* get the next TD in the ring */
|
|
ep->empty_td = next_bd(ep->td_base, ep->empty_td, td_status);
|
|
fhci_usb_enable_interrupt(usb);
|
|
pkt->priv_data = td;
|
|
out_be32(&td->buf_ptr, virt_to_phys(pkt->data));
|
|
/* sets up transaction parameters - addr,endp,dir,and type */
|
|
extra_data = (dest_ep << TD_ENDP_SHIFT) | dest_addr;
|
|
switch (trans_type) {
|
|
case FHCI_TA_IN:
|
|
extra_data |= TD_TOK_IN;
|
|
break;
|
|
case FHCI_TA_OUT:
|
|
extra_data |= TD_TOK_OUT;
|
|
break;
|
|
case FHCI_TA_SETUP:
|
|
extra_data |= TD_TOK_SETUP;
|
|
break;
|
|
}
|
|
if (trans_mode == FHCI_TF_ISO)
|
|
extra_data |= TD_ISO;
|
|
out_be16(&td->extra, extra_data);
|
|
|
|
/* sets up the buffer descriptor */
|
|
td_status = ((td_status & TD_W) | TD_R | TD_L | TD_I | TD_CNF);
|
|
if (!(pkt->info & PKT_NO_CRC))
|
|
td_status |= TD_TC;
|
|
|
|
switch (trans_type) {
|
|
case FHCI_TA_IN:
|
|
if (data_toggle)
|
|
pkt->info |= PKT_PID_DATA1;
|
|
else
|
|
pkt->info |= PKT_PID_DATA0;
|
|
break;
|
|
default:
|
|
if (data_toggle) {
|
|
td_status |= TD_PID_DATA1;
|
|
pkt->info |= PKT_PID_DATA1;
|
|
} else {
|
|
td_status |= TD_PID_DATA0;
|
|
pkt->info |= PKT_PID_DATA0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ((dest_speed == FHCI_LOW_SPEED) &&
|
|
(usb->port_status == FHCI_PORT_FULL))
|
|
td_status |= TD_LSP;
|
|
|
|
out_be16(&td->status, td_status);
|
|
|
|
/* set up buffer length */
|
|
if (trans_type == FHCI_TA_IN)
|
|
out_be16(&td->length, pkt->len + CRC_SIZE);
|
|
else
|
|
out_be16(&td->length, pkt->len);
|
|
|
|
/* put the frame to the confirmation queue */
|
|
cq_put(&ep->conf_frame_Q, pkt);
|
|
|
|
if (cq_howmany(&ep->conf_frame_Q) == 1)
|
|
out_8(&usb->fhci->regs->usb_uscom, USB_CMD_STR_FIFO);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Reset the Tx BD ring */
|
|
void fhci_flush_bds(struct fhci_usb *usb)
|
|
{
|
|
u16 td_status;
|
|
struct usb_td __iomem *td;
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
td = ep->td_base;
|
|
while (1) {
|
|
td_status = in_be16(&td->status);
|
|
in_be32(&td->buf_ptr);
|
|
in_be16(&td->extra);
|
|
|
|
/* if the TD is not empty - we'll confirm it as Timeout */
|
|
if (td_status & TD_R)
|
|
out_be16(&td->status, (td_status & ~TD_R) | TD_TO);
|
|
/* if this TD is dummy - let's skip this TD */
|
|
else if (in_be32(&td->buf_ptr) == DUMMY_BD_BUFFER)
|
|
out_be32(&td->buf_ptr, DUMMY2_BD_BUFFER);
|
|
/* if this is the last TD - break */
|
|
if (td_status & TD_W)
|
|
break;
|
|
|
|
td++;
|
|
}
|
|
|
|
fhci_td_transaction_confirm(usb);
|
|
|
|
td = ep->td_base;
|
|
do {
|
|
out_be16(&td->status, 0);
|
|
out_be16(&td->length, 0);
|
|
out_be32(&td->buf_ptr, 0);
|
|
out_be16(&td->extra, 0);
|
|
td++;
|
|
} while (!(in_be16(&td->status) & TD_W));
|
|
out_be16(&td->status, TD_W); /* for last TD set Wrap bit */
|
|
out_be16(&td->length, 0);
|
|
out_be32(&td->buf_ptr, 0);
|
|
out_be16(&td->extra, 0);
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_bd_ptr,
|
|
in_be16(&ep->ep_pram_ptr->tx_base));
|
|
out_be32(&ep->ep_pram_ptr->tx_state, 0);
|
|
out_be16(&ep->ep_pram_ptr->tx_cnt, 0);
|
|
ep->empty_td = ep->td_base;
|
|
ep->conf_td = ep->td_base;
|
|
}
|
|
|
|
/*
|
|
* Flush all transmitted packets from TDs in the actual frame.
|
|
* 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 fhci_flush_actual_frame(struct fhci_usb *usb)
|
|
{
|
|
u8 mode;
|
|
u16 tb_ptr;
|
|
u16 td_status;
|
|
u32 buf_ptr;
|
|
struct usb_td __iomem *td;
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
/* disable the USB controller */
|
|
mode = in_8(&usb->fhci->regs->usb_usmod);
|
|
out_8(&usb->fhci->regs->usb_usmod, mode & ~USB_MODE_EN);
|
|
|
|
tb_ptr = in_be16(&ep->ep_pram_ptr->tx_bd_ptr);
|
|
td = cpm_muram_addr(tb_ptr);
|
|
td_status = in_be16(&td->status);
|
|
buf_ptr = in_be32(&td->buf_ptr);
|
|
in_be16(&td->extra);
|
|
do {
|
|
if (td_status & TD_R) {
|
|
out_be16(&td->status, (td_status & ~TD_R) | TD_TO);
|
|
} else {
|
|
out_be32(&td->buf_ptr, 0);
|
|
ep->already_pushed_dummy_bd = false;
|
|
break;
|
|
}
|
|
|
|
/* advance the TD pointer */
|
|
td = next_bd(ep->td_base, td, td_status);
|
|
td_status = in_be16(&td->status);
|
|
buf_ptr = in_be32(&td->buf_ptr);
|
|
in_be16(&td->extra);
|
|
} while ((td_status & TD_R) || buf_ptr);
|
|
|
|
fhci_td_transaction_confirm(usb);
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_bd_ptr,
|
|
in_be16(&ep->ep_pram_ptr->tx_base));
|
|
out_be32(&ep->ep_pram_ptr->tx_state, 0);
|
|
out_be16(&ep->ep_pram_ptr->tx_cnt, 0);
|
|
ep->empty_td = ep->td_base;
|
|
ep->conf_td = ep->td_base;
|
|
|
|
usb->actual_frame->frame_status = FRAME_TIMER_END_TRANSMISSION;
|
|
|
|
/* reset the event register */
|
|
out_be16(&usb->fhci->regs->usb_usber, 0xffff);
|
|
/* enable the USB controller */
|
|
out_8(&usb->fhci->regs->usb_usmod, mode | USB_MODE_EN);
|
|
}
|
|
|
|
/* handles Tx confirm and Tx error interrupt */
|
|
void fhci_tx_conf_interrupt(struct fhci_usb *usb)
|
|
{
|
|
fhci_td_transaction_confirm(usb);
|
|
|
|
/*
|
|
* Schedule another transaction to this frame only if we have
|
|
* already confirmed all transaction in the frame.
|
|
*/
|
|
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)))
|
|
fhci_schedule_transactions(usb);
|
|
}
|
|
|
|
void fhci_host_transmit_actual_frame(struct fhci_usb *usb)
|
|
{
|
|
u16 tb_ptr;
|
|
u16 td_status;
|
|
struct usb_td __iomem *td;
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
tb_ptr = in_be16(&ep->ep_pram_ptr->tx_bd_ptr);
|
|
td = cpm_muram_addr(tb_ptr);
|
|
|
|
if (in_be32(&td->buf_ptr) == DUMMY_BD_BUFFER) {
|
|
struct usb_td __iomem *old_td = td;
|
|
|
|
ep->already_pushed_dummy_bd = false;
|
|
td_status = in_be16(&td->status);
|
|
/* gets the next TD in the ring */
|
|
td = next_bd(ep->td_base, td, td_status);
|
|
tb_ptr = cpm_muram_offset(td);
|
|
out_be16(&ep->ep_pram_ptr->tx_bd_ptr, tb_ptr);
|
|
|
|
/* start transmit only if we have something in the TDs */
|
|
if (in_be16(&td->status) & TD_R)
|
|
out_8(&usb->fhci->regs->usb_uscom, USB_CMD_STR_FIFO);
|
|
|
|
if (in_be32(&ep->conf_td->buf_ptr) == DUMMY_BD_BUFFER) {
|
|
out_be32(&old_td->buf_ptr, 0);
|
|
ep->conf_td = next_bd(ep->td_base, ep->conf_td,
|
|
td_status);
|
|
} else {
|
|
out_be32(&old_td->buf_ptr, DUMMY2_BD_BUFFER);
|
|
}
|
|
}
|
|
}
|