/*
* This function is called as a result of the "eth_drv_recv()" call above.
* It's job is to actually fetch data for a packet from the hardware once
* memory buffers have been allocated for the packet. Note that the buffers
* may come in pieces, using a scatter-gather list. This allows for more
* efficient processing in the upper layers of the stack.
*/
static void
dp83902a_recv(u8 *data, int len)
{
struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
u8 *base = dp->base;
int i, mlen;
u8 saved_char = 0;
bool saved;
#if DEBUG & 4
int dx;
#endif
DEBUG_FUNCTION();
#if DEBUG & 5
printf("Rx packet %d length %d\n", dp->rx_next, len);
#endif
/* Read incoming packet data */
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
DP_OUT(base, DP_RBCL, len & 0xFF);
DP_OUT(base, DP_RBCH, len >> 8);
DP_OUT(base, DP_RSAL, 4); /* Past header */
DP_OUT(base, DP_RSAH, dp->rx_next);
DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
CYGACC_CALL_IF_DELAY_US(10);
#endif
saved = false;
for (i = 0; i < 1; i++) {
if (data) {
mlen = len;
#if DEBUG & 4
printf(" sg buf %08lx len %08x \n", (u32) data, mlen);
dx = 0;
#endif
while (0 < mlen) {
/* Saved byte from previous loop? */
if (saved) {
*data++ = saved_char;
mlen--;
saved = false;
continue;
}
{
u8 tmp;
DP_IN_DATA(dp->data, tmp);
#if DEBUG & 4
printf(" %02x", tmp);
if (0 == (++dx % 16)) printf("\n ");
#endif
*data++ = tmp;;
mlen--;
}
}
#if DEBUG & 4
printf("\n");
#endif
}
}
}
/*
* This function is called when a packet has been received. It's job is
* to prepare to unload the packet from the hardware. Once the length of
* the packet is known, the upper layer of the driver can be told. When
* the upper layer is ready to unload the packet, the internal function
* 'dp83902a_recv' will be called to actually fetch it from the hardware.
*/
static void
dp83902a_RxEvent(void)
{
struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
u8 *base = dp->base;
__maybe_unused u8 rsr;
u8 rcv_hdr[4];
int i, len, pkt, cur;
DEBUG_FUNCTION();
DP_IN(base, DP_RSR, rsr);
while (true) {
/* Read incoming packet header */
DP_OUT(base, DP_CR, DP_CR_PAGE1 | DP_CR_NODMA | DP_CR_START);
DP_IN(base, DP_P1_CURP, cur);
DP_OUT(base, DP_P1_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
DP_IN(base, DP_BNDRY, pkt);
pkt += 1;
if (pkt == dp->rx_buf_end)
pkt = dp->rx_buf_start;
if (pkt == cur) {
break;
}
DP_OUT(base, DP_RBCL, sizeof(rcv_hdr));
DP_OUT(base, DP_RBCH, 0);
DP_OUT(base, DP_RSAL, 0);
DP_OUT(base, DP_RSAH, pkt);
if (dp->rx_next == pkt) {
if (cur == dp->rx_buf_start)
DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1);
else
DP_OUT(base, DP_BNDRY, cur - 1); /* Update pointer */
return;
}
dp->rx_next = pkt;
DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
CYGACC_CALL_IF_DELAY_US(10);
#endif
/* read header (get data size)*/
for (i = 0; i < sizeof(rcv_hdr);) {
DP_IN_DATA(dp->data, rcv_hdr[i++]);
}
#if DEBUG & 5
printf("rx hdr %02x %02x %02x %02x\n",
rcv_hdr[0], rcv_hdr[1], rcv_hdr[2], rcv_hdr[3]);
#endif
len = ((rcv_hdr[3] << 8) | rcv_hdr[2]) - sizeof(rcv_hdr);
/* data read */
uboot_push_packet_len(len);
if (rcv_hdr[1] == dp->rx_buf_start)
DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1);
else
DP_OUT(base, DP_BNDRY, rcv_hdr[1] - 1); /* Update pointer */
}
}
/*
* This function is called to "start up" the interface. It may be called
* multiple times, even when the hardware is already running. It will be
* called whenever something "hardware oriented" changes and should leave
* the hardware ready to send/receive packets.
*/
static void
dp83902a_start(u8 * enaddr)
{
dp83902a_priv_data_t *dp = &nic;
u8 *base = dp->base;
int i;
debug("The MAC is %pM\n", enaddr);
DEBUG_FUNCTION();
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
DP_OUT(base, DP_DCR, DP_DCR_INIT);
DP_OUT(base, DP_RBCH, 0); /* Remote byte count */
DP_OUT(base, DP_RBCL, 0);
DP_OUT(base, DP_RCR, DP_RCR_MON); /* Accept no packets */
DP_OUT(base, DP_TCR, DP_TCR_LOCAL); /* Transmitter [virtually] off */
DP_OUT(base, DP_TPSR, dp->tx_buf1); /* Transmitter start page */
dp->tx1 = dp->tx2 = 0;
dp->tx_next = dp->tx_buf1;
dp->tx_started = false;
dp->running = true;
DP_OUT(base, DP_PSTART, dp->rx_buf_start); /* Receive ring start page */
DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1); /* Receive ring boundary */
DP_OUT(base, DP_PSTOP, dp->rx_buf_end); /* Receive ring end page */
dp->rx_next = dp->rx_buf_start - 1;
dp->running = true;
DP_OUT(base, DP_ISR, 0xFF); /* Clear any pending interrupts */
DP_OUT(base, DP_IMR, DP_IMR_All); /* Enable all interrupts */
DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1 | DP_CR_STOP); /* Select page 1 */
DP_OUT(base, DP_P1_CURP, dp->rx_buf_start); /* Current page - next free page for Rx */
dp->running = true;
for (i = 0; i < ETHER_ADDR_LEN; i++) {
/* FIXME */
/*((vu_short*)( base + ((DP_P1_PAR0 + i) * 2) +
* 0x1400)) = enaddr[i];*/
DP_OUT(base, DP_P1_PAR0+i, enaddr[i]);
}
/* Enable and start device */
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
DP_OUT(base, DP_TCR, DP_TCR_NORMAL); /* Normal transmit operations */
DP_OUT(base, DP_RCR, DP_RCR_AB); /* Accept broadcast, no errors, no multicast */
dp->running = true;
}
/*
* This routine is called to send data to the hardware. It is known a-priori
* that there is free buffer space (dp->tx_next).
*/
static void
dp83902a_send(u8 *data, int total_len, u32 key)
{
struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
u8 *base = dp->base;
int len, start_page, pkt_len, i, isr;
#if DEBUG & 4
int dx;
#endif
DEBUG_FUNCTION();
len = pkt_len = total_len;
if (pkt_len < IEEE_8023_MIN_FRAME)
pkt_len = IEEE_8023_MIN_FRAME;
start_page = dp->tx_next;
if (dp->tx_next == dp->tx_buf1) {
dp->tx1 = start_page;
dp->tx1_len = pkt_len;
dp->tx1_key = key;
dp->tx_next = dp->tx_buf2;
} else {
dp->tx2 = start_page;
dp->tx2_len = pkt_len;
dp->tx2_key = key;
dp->tx_next = dp->tx_buf1;
}
#if DEBUG & 5
printf("TX prep page %d len %d\n", start_page, pkt_len);
#endif
DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
{
/*
* Dummy read. The manual sez something slightly different,
* but the code is extended a bit to do what Hitachi's monitor
* does (i.e., also read data).
*/
__maybe_unused u16 tmp;
int len = 1;
DP_OUT(base, DP_RSAL, 0x100 - len);
DP_OUT(base, DP_RSAH, (start_page - 1) & 0xff);
DP_OUT(base, DP_RBCL, len);
DP_OUT(base, DP_RBCH, 0);
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_RDMA | DP_CR_START);
DP_IN_DATA(dp->data, tmp);
}
#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
/*
* Stall for a bit before continuing to work around random data
* corruption problems on some platforms.
*/
CYGACC_CALL_IF_DELAY_US(1);
#endif
/* Send data to device buffer(s) */
DP_OUT(base, DP_RSAL, 0);
DP_OUT(base, DP_RSAH, start_page);
DP_OUT(base, DP_RBCL, pkt_len & 0xFF);
DP_OUT(base, DP_RBCH, pkt_len >> 8);
DP_OUT(base, DP_CR, DP_CR_WDMA | DP_CR_START);
/* Put data into buffer */
#if DEBUG & 4
printf(" sg buf %08lx len %08x\n ", (u32)data, len);
dx = 0;
#endif
while (len > 0) {
#if DEBUG & 4
printf(" %02x", *data);
if (0 == (++dx % 16)) printf("\n ");
#endif
DP_OUT_DATA(dp->data, *data++);
len--;
}
#if DEBUG & 4
printf("\n");
#endif
if (total_len < pkt_len) {
#if DEBUG & 4
printf(" + %d bytes of padding\n", pkt_len - total_len);
#endif
/* Padding to 802.3 length was required */
for (i = total_len; i < pkt_len;) {
i++;
DP_OUT_DATA(dp->data, 0);
}
}
#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
/*
* After last data write, delay for a bit before accessing the
* device again, or we may get random data corruption in the last
* datum (on some platforms).
*/
CYGACC_CALL_IF_DELAY_US(1);
#endif
/* Wait for DMA to complete */
do {
DP_IN(base, DP_ISR, isr);
} while ((isr & DP_ISR_RDC) == 0);
/* Then disable DMA */
DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
/* Start transmit if not already going */
if (!dp->tx_started) {
if (start_page == dp->tx1) {
dp->tx_int = 1; /* Expecting interrupt from BUF1 */
} else {
dp->tx_int = 2; /* Expecting interrupt from BUF2 */
}
dp83902a_start_xmit(start_page, pkt_len);
}
}
static void
#else
static int
#endif
sc_lpe_card_handler(cyg_addrword_t param)
{
struct eth_drv_sc *sc = (struct eth_drv_sc *)param;
dp83902a_priv_data_t *dp = (dp83902a_priv_data_t*)sc->driver_private;
struct cf_slot *slot;
struct cf_cftable cftable;
struct cf_config config;
int i, len, ptr, cor = 0;
unsigned char buf[256], *cp;
cyg_uint8* base;
unsigned char *vers_product, *vers_manuf, *vers_revision, *vers_date;
#ifndef CYGPKG_KERNEL
int tries = 0;
#endif
bool first = true;
slot = (struct cf_slot*)dp->plf_priv;
cyg_drv_dsr_lock();
while (true) {
cyg_drv_dsr_unlock(); // Give DSRs a chance to run (card insertion)
cyg_drv_dsr_lock();
if ((slot->state == CF_SLOT_STATE_Inserted) ||
((slot->state == CF_SLOT_STATE_Ready) && first)) {
first = false;
if (slot->state != CF_SLOT_STATE_Ready) {
cf_change_state(slot, CF_SLOT_STATE_Ready);
}
if (slot->state != CF_SLOT_STATE_Ready) {
diag_printf("CF card won't go ready!\n");
#ifndef CYGPKG_KERNEL
return false;
#else
continue;
#endif
}
len = sizeof(buf);
ptr = 0;
if (cf_get_CIS(slot, CF_CISTPL_MANFID, buf, &len, &ptr)) {
if (*(short *)&buf[2] != SC_LPE_MANUF) {
diag_printf("Not a SC LPE, sorry\n");
continue;
}
}
ptr = 0;
if (cf_get_CIS(slot, CF_CISTPL_VERS_1, buf, &len, &ptr)) {
// Find individual strings
cp = &buf[4];
vers_product = cp;
while (*cp++) ; // Skip to nul
vers_manuf = cp;
while (*cp++) ; // Skip to nul
vers_revision = cp;
while (*cp++) ; // Skip to nul
vers_date = cp;
#ifndef CYGPKG_KERNEL
if (tries != 0) diag_printf("\n");
diag_printf("%s: %s %s %s\n", vers_manuf, vers_product, vers_revision, vers_date);
#endif
}
ptr = 0;
if (cf_get_CIS(slot, CF_CISTPL_CONFIG, buf, &len, &ptr)) {
if (cf_parse_config(buf, len, &config)) {
cor = config.base;
}
}
if (!cor) {
// diag_printf("Couldn't find COR pointer!\n");
continue;
}
ptr = 0;
if (cf_get_CIS(slot, CF_CISTPL_CFTABLE_ENTRY, buf, &len, &ptr)) {
if (cf_parse_cftable(buf, len, &cftable)) {
cyg_uint8 tmp;
// Initialize dp83902a IO details
dp->base = base = (cyg_uint8*)&slot->io[cftable.io_space.base[0]];
dp->data = base + DP_DATA;
dp->interrupt = slot->int_num;
cf_set_COR(slot, cor, cftable.cor);
// Reset card (read issues RESET, write clears it)
HAL_READ_UINT8(base+DP_CARD_RESET, tmp);
HAL_WRITE_UINT8(base+DP_CARD_RESET, tmp);
// Wait for card
do {
DP_IN(base, DP_ISR, tmp);
} while (0 == (tmp & DP_ISR_RESET));
// Fetch hardware address from card - terrible, but not well defined
// Patterned after what Linux drivers do
if (!dp->hardwired_esa) {
static unsigned char sc_lpe_addr[] = { 0x00, 0xC0, 0x1B, 0x00, 0x99, 0x9E};
if ((slot->attr[0x1C0] == sc_lpe_addr[0]) &&
(slot->attr[0x1C2] == sc_lpe_addr[1]) &&
(slot->attr[0x1C4] == sc_lpe_addr[2])) {
sc_lpe_addr[3] = slot->attr[0x1C6];
sc_lpe_addr[4] = slot->attr[0x1C8];
sc_lpe_addr[5] = slot->attr[0x1CA];
} else {
// Coudn't find it in the CIS (attribute) data
unsigned char prom[32];
// Tell device to give up ESA
DP_OUT(base, DP_DCR, 0x48); // Bytewide access
DP_OUT(base, DP_RBCH, 0); // Remote byte count
DP_OUT(base, DP_RBCL, 0);
DP_OUT(base, DP_ISR, 0xFF); // Clear any pending interrupts
DP_OUT(base, DP_IMR, 0x00); // Mask all interrupts
DP_OUT(base, DP_RCR, 0x20); // Monitor
DP_OUT(base, DP_TCR, 0x02); // loopback
DP_OUT(base, DP_RBCH, 32); // Remote byte count
DP_OUT(base, DP_RBCL, 0);
DP_OUT(base, DP_RSAL, 0); // Remote address
DP_OUT(base, DP_RSAH, 0);
DP_OUT(base, DP_CR, DP_CR_START|DP_CR_RDMA); // Read data
for (i = 0; i < 32; i++) {
HAL_READ_UINT8(base+DP_DATAPORT, prom[i]);
}
if ((prom[0] == sc_lpe_addr[0]) &&
(prom[2] == sc_lpe_addr[1]) &&
(prom[4] == sc_lpe_addr[2])) {
diag_printf("Getting address from port\n");
sc_lpe_addr[3] = prom[6];
sc_lpe_addr[4] = prom[8];
sc_lpe_addr[5] = prom[10];
} else {
diag_printf("No valid ESA found in CIS! Hardwiring to 00:C0:1B:00:99:9E\n");
}
}
for (i = 0; i < 6; i++) {
dp->esa[i] = sc_lpe_addr[i];
}
}
// Initialize upper level driver
(sc->funs->eth_drv->init)(sc, dp->esa);
// Tell system card is ready to talk
dp->tab->status = CYG_NETDEVTAB_STATUS_AVAIL;
#ifndef CYGPKG_KERNEL
cyg_drv_dsr_unlock();
return true;
#endif
} else {
diag_printf("Can't parse CIS\n");
continue;
}
} else {
diag_printf("Can't fetch config info\n");
continue;
}
} else if (slot->state == CF_SLOT_STATE_Removed) {
diag_printf("Compact Flash card removed!\n");
} else {
cyg_drv_dsr_unlock();
do_delay(50); // FIXME!
#ifndef CYGPKG_KERNEL
if (tries == 0) diag_printf("... Waiting for network card: ");
diag_printf(".");
if (++tries == 10) {
// 5 seconds have elapsed - give up
return false;
}
cf_hwr_poll(slot); // Check to see if card has been inserted
#endif
cyg_drv_dsr_lock();
}
}
}