Subversion Repositories test_project

/*
 * 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