mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 00:26:40 +07:00
cf61fdb944
The struct fhci_regs (in drivers/usb/host/fhci.h) is basically a redefinition of the struct qe_usb_ctlr (in arch/powerpc/include/asm/immap_qe.h). The qe_usb_ctlr struct is preferrable once it uses accurately the registers' names found in the Freescale's QUICC Engine Block Reference Manuals (QEIWRM.pdf Rev.4.4 Chapter 19 for MPC836xE series and MPC8323ERM.pdf Rev.2 Chapter 36 for MPC832xE series), making easier to map the FHCI device driver to the hardware manual. Also, as the FHCI driver uses the USB Controller registers, the name qe_usb_ctlr is a more precise representation of the hardware than fhci_regs. Signed-off-by: Guilherme Maciel Ferreira <guilherme.maciel.ferreira@gmail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
627 lines
16 KiB
C
627 lines
16 KiB
C
/*
|
|
* 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>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*/
|
|
|
|
#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 == false) {
|
|
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(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 extra_data;
|
|
u16 td_status;
|
|
u32 buf;
|
|
struct usb_td __iomem *td;
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
td = ep->td_base;
|
|
while (1) {
|
|
td_status = in_be16(&td->status);
|
|
buf = in_be32(&td->buf_ptr);
|
|
extra_data = 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 extra_data;
|
|
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);
|
|
extra_data = 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);
|
|
extra_data = 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);
|
|
}
|
|
}
|
|
}
|