| /* | |
| * TX ucode for the Intel IXP2400 in POS-PHY mode. | |
| * Copyright (C) 2004, 2005 Lennert Buytenhek | |
| * Dedicated to Marija Kulikova. | |
| * | |
| * 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. | |
| * | |
| * Assumptions made in this code: | |
| * - The IXP2400 MSF is configured for POS-PHY mode, in a mode where | |
| * only one TBUF partition is used. This includes, for example, | |
| * 1x32 SPHY and 1x32 MPHY32, but not 4x8 SPHY or 1x32 MPHY4. (This | |
| * is not an exhaustive list.) | |
| * - The TBUF uses 64-byte mpackets. | |
| * - TX descriptors reside in SRAM, and have the following format: | |
| * struct tx_desc | |
| * { | |
| * // to uengine | |
| * u32 buf_phys_addr; | |
| * u32 pkt_length; | |
| * u32 channel; | |
| * }; | |
| * - Packet data resides in DRAM. | |
| * - Packet buffer addresses are 8-byte aligned. | |
| * - Scratch ring 2 is tx_pending. | |
| * - Scratch ring 3 is tx_done, and has status condition 'full'. | |
| * - This code is run on all eight threads of the microengine it runs on. | |
| */ | |
| #define TX_SEQUENCE_0 0x0060 | |
| #define TBUF_CTRL 0x1800 | |
| #define PARTITION_SIZE 128 | |
| #define PARTITION_THRESH 96 | |
| .sig volatile sig1 | |
| .sig volatile sig2 | |
| .sig volatile sig3 | |
| .reg @old_tx_seq_0 | |
| .reg @mpkts_in_flight | |
| .reg @next_tbuf_mpacket | |
| .reg @buffer_handle | |
| .reg @buffer_start | |
| .reg @packet_length | |
| .reg @channel | |
| .reg @packet_offset | |
| .reg zero | |
| immed[zero, 0] | |
| /* | |
| * Skip context 0 initialisation? | |
| */ | |
| .begin | |
| br!=ctx[0, mpacket_tx_loop#] | |
| .end | |
| /* | |
| * Wait until all pending TBUF elements have been transmitted. | |
| */ | |
| .begin | |
| .reg read $tx | |
| .sig zzz | |
| loop_empty#: | |
| msf[read, $tx, zero, TX_SEQUENCE_0, 1], ctx_swap[zzz] | |
| alu_shf[--, --, b, $tx, >>31] | |
| beq[loop_empty#] | |
| alu[@old_tx_seq_0, --, b, $tx] | |
| .end | |
| immed[@mpkts_in_flight, 0] | |
| alu[@next_tbuf_mpacket, @old_tx_seq_0, and, (PARTITION_SIZE - 1)] | |
| immed[@buffer_handle, 0] | |
| /* | |
| * Initialise signal pipeline. | |
| */ | |
| .begin | |
| local_csr_wr[SAME_ME_SIGNAL, (&sig1 << 3)] | |
| .set_sig sig1 | |
| local_csr_wr[SAME_ME_SIGNAL, (&sig2 << 3)] | |
| .set_sig sig2 | |
| local_csr_wr[SAME_ME_SIGNAL, (&sig3 << 3)] | |
| .set_sig sig3 | |
| .end | |
| mpacket_tx_loop#: | |
| .begin | |
| .reg tbuf_element_index | |
| .reg buffer_handle | |
| .reg sop_eop | |
| .reg packet_data | |
| .reg channel | |
| .reg mpacket_size | |
| /* | |
| * If there is no packet currently being transmitted, | |
| * dequeue the next TX descriptor, and fetch the buffer | |
| * address, packet length and destination channel number. | |
| */ | |
| .begin | |
| .reg read $stemp $stemp2 $stemp3 | |
| .xfer_order $stemp $stemp2 $stemp3 | |
| .sig zzz | |
| ctx_arb[sig1] | |
| alu[--, --, b, @buffer_handle] | |
| bne[already_got_packet#] | |
| tx_nobufs#: | |
| scratch[get, $stemp, zero, 8, 1], ctx_swap[zzz] | |
| alu[@buffer_handle, --, b, $stemp] | |
| beq[tx_nobufs#] | |
| sram[read, $stemp, $stemp, 0, 3], ctx_swap[zzz] | |
| alu[@buffer_start, --, b, $stemp] | |
| alu[@packet_length, --, b, $stemp2] | |
| beq[zero_byte_packet#] | |
| alu[@channel, --, b, $stemp3] | |
| immed[@packet_offset, 0] | |
| already_got_packet#: | |
| local_csr_wr[SAME_ME_SIGNAL, (0x80 | (&sig1 << 3))] | |
| .end | |
| /* | |
| * Determine tbuf element index, SOP/EOP flags, mpacket | |
| * offset and mpacket size and cache buffer_handle and | |
| * channel number. | |
| */ | |
| .begin | |
| alu[tbuf_element_index, --, b, @next_tbuf_mpacket] | |
| alu[@next_tbuf_mpacket, @next_tbuf_mpacket, +, 1] | |
| alu[@next_tbuf_mpacket, @next_tbuf_mpacket, and, | |
| (PARTITION_SIZE - 1)] | |
| alu[buffer_handle, --, b, @buffer_handle] | |
| immed[@buffer_handle, 0] | |
| immed[sop_eop, 1] | |
| alu[packet_data, --, b, @packet_offset] | |
| bne[no_sop#] | |
| alu[sop_eop, sop_eop, or, 2] | |
| no_sop#: | |
| alu[packet_data, packet_data, +, @buffer_start] | |
| alu[channel, --, b, @channel] | |
| alu[mpacket_size, @packet_length, -, @packet_offset] | |
| alu[--, 64, -, mpacket_size] | |
| bhs[eop#] | |
| alu[@buffer_handle, --, b, buffer_handle] | |
| immed[mpacket_size, 64] | |
| alu[sop_eop, sop_eop, and, 2] | |
| eop#: | |
| alu[@packet_offset, @packet_offset, +, mpacket_size] | |
| .end | |
| /* | |
| * Wait until there's enough space in the TBUF. | |
| */ | |
| .begin | |
| .reg read $tx | |
| .reg temp | |
| .sig zzz | |
| ctx_arb[sig2] | |
| br[test_space#] | |
| loop_space#: | |
| msf[read, $tx, zero, TX_SEQUENCE_0, 1], ctx_swap[zzz] | |
| alu[temp, $tx, -, @old_tx_seq_0] | |
| alu[temp, temp, and, 0xff] | |
| alu[@mpkts_in_flight, @mpkts_in_flight, -, temp] | |
| alu[@old_tx_seq_0, --, b, $tx] | |
| test_space#: | |
| alu[--, PARTITION_THRESH, -, @mpkts_in_flight] | |
| blo[loop_space#] | |
| alu[@mpkts_in_flight, @mpkts_in_flight, +, 1] | |
| local_csr_wr[SAME_ME_SIGNAL, (0x80 | (&sig2 << 3))] | |
| .end | |
| /* | |
| * Copy the packet data to the TBUF. | |
| */ | |
| .begin | |
| .reg temp | |
| .sig copy_sig | |
| alu[temp, mpacket_size, -, 1] | |
| alu_shf[temp, 0x10, or, temp, >>3] | |
| alu_shf[temp, 0x10, or, temp, <<21] | |
| alu_shf[temp, temp, or, tbuf_element_index, <<11] | |
| alu_shf[--, temp, or, 1, <<18] | |
| dram[tbuf_wr, --, packet_data, 0, max_8], | |
| indirect_ref, sig_done[copy_sig] | |
| ctx_arb[copy_sig] | |
| .end | |
| /* | |
| * Mark TBUF element as ready-to-be-transmitted. | |
| */ | |
| .begin | |
| .reg write $tsw $tsw2 | |
| .xfer_order $tsw $tsw2 | |
| .reg temp | |
| .sig zzz | |
| alu_shf[temp, channel, or, mpacket_size, <<24] | |
| alu_shf[$tsw, temp, or, sop_eop, <<8] | |
| immed[$tsw2, 0] | |
| immed[temp, TBUF_CTRL] | |
| alu_shf[temp, temp, or, tbuf_element_index, <<3] | |
| msf[write, $tsw, temp, 0, 2], ctx_swap[zzz] | |
| .end | |
| /* | |
| * Resynchronise. | |
| */ | |
| .begin | |
| ctx_arb[sig3] | |
| local_csr_wr[SAME_ME_SIGNAL, (0x80 | (&sig3 << 3))] | |
| .end | |
| /* | |
| * If this was an EOP mpacket, recycle the TX buffer | |
| * and signal the host. | |
| */ | |
| .begin | |
| .reg write $stemp | |
| .sig zzz | |
| alu[--, sop_eop, and, 1] | |
| beq[mpacket_tx_loop#] | |
| tx_done_ring_full#: | |
| br_inp_state[SCR_Ring3_Status, tx_done_ring_full#] | |
| alu[$stemp, --, b, buffer_handle] | |
| scratch[put, $stemp, zero, 12, 1], ctx_swap[zzz] | |
| cap[fast_wr, 0, XSCALE_INT_A] | |
| br[mpacket_tx_loop#] | |
| .end | |
| .end | |
| zero_byte_packet#: | |
| halt | |