URL https://opencores.org/ocsvn/6809_6309_compatible_core/6809_6309_compatible_core/trunk

Subversion Repositories 6809_6309_compatible_core

[/] [6809_6309_compatible_core/] [trunk/] [rtl/] [verilog/] [alu16.v] - Blame information for rev 18

Details | Compare with Previous | View Log


/*
 * (c) 2013 Alejandro Paz
 *
 *
 * An alu core
 *
 * ADD, ADC, DAA, SUB, SBC, COM, NEG, CMP, ASR, ASL, ROR, ROL, RCR, RCL
 *
 *
 *
 */
`include "defs.v"
 
 
module alu(
        input wire clk_in,
        input wire [15:0] a_in,
        input wire [15:0] b_in,
        input wire [7:0] CCR, /* condition code register */
        input wire [4:0] opcode_in, /* ALU opcode */
        input wire sz_in, /* size, low 8 bit, high 16 bit */
        output reg [15:0] q_out, /* ALU result */
        output reg [7:0] CCRo
        );
 
wire [7:0] ccr8_out, q8_out;
wire [15:0] q16_out;
wire [3:0] ccr16_out;
wire [15:0] q16_mul;
reg [15:0] ra_in, rb_in;
reg [4:0] rop_in;
 
mul8x8 mulu(clk_in, a_in[7:0], b_in[7:0], q16_mul);
alu8 alu8(clk_in, ra_in[7:0], rb_in[7:0], CCR, rop_in, q8_out, ccr8_out);
alu16 alu16(clk_in, ra_in, rb_in, CCR, rop_in, q16_mul, q16_out, ccr16_out);
 
always @(posedge clk_in)
        begin
                ra_in <= a_in;
                rb_in <= b_in;
                rop_in <= opcode_in;
        end
 
always @(*)
        begin
                if (sz_in)
                        begin
                                q_out = q16_out;
                                CCRo = { CCR[7:4], ccr16_out };
                        end
                else
                        begin
                                q_out = { 8'h0, q8_out };
                                CCRo = ccr8_out;
                        end
        end
 
 
endmodule
/**
 * Simple 3 functions logic
 *
 */
module logic8(
        input wire [7:0] a_in,
        input wire [7:0] b_in,
        input wire [1:0] opcode_in, /* ALU opcode */
        output reg [7:0] q_out /* ALU result */
        );
 
always @(*)
        begin
                case (opcode_in)
                        2'b00: q_out = b_in;
                        2'b01: q_out = a_in & b_in;
                        2'b10: q_out = a_in | b_in;
                        2'b11: q_out = a_in ^ b_in;
                endcase
        end
 
endmodule
 
/**
 * Simple ADD/SUB module
 *
 */
module arith8(
        input wire [7:0] a_in,
        input wire [7:0] b_in,
        input wire carry_in, /* condition code register */
        input wire half_c_in,
        input wire [1:0] opcode_in, /* ALU opcode */
        output reg [7:0] q_out, /* ALU result */
        output reg carry_out,
        output reg overflow_out,
        output reg half_c_out
        );
 
wire carry;
assign carry = opcode_in[1] ? carry_in:1'b0;
 
always @(*)
        begin
                case (opcode_in[0])
                        1'b0: { carry_out, q_out } = { 1'b0, a_in } + { 1'b0, b_in } + { 8'h0, carry }; // ADD/ADC
                        1'b1: { carry_out, q_out } = { 1'b0, a_in } - { 1'b0, b_in } - { 8'h0, carry }; // SUB/SBC
                endcase
        end
 
always @(*)
        begin
                case (opcode_in[0])
                        1'b0: overflow_out = (a_in[7] & b_in[7] & (~q_out[7])) | ((~a_in[7]) & (~b_in[7]) & q_out[7]);
                        1'b1: overflow_out = (a_in[7] & (~b_in[7]) & (~q_out[7])) | ((~a_in[7]) & b_in[7] & q_out[7]);
                endcase
        end
 
always @(*)
        begin
                case (opcode_in[0])
                        1'b0: half_c_out = (a_in[4] ^ b_in[4] ^ q_out[4]);
                        1'b1: half_c_out = half_c_in;
                endcase
        end
 
endmodule
 
/**
 * Simple ADD/SUB module
 *
 */
module arith16(
        input wire [15:0] a_in,
        input wire [15:0] b_in,
        input wire carry_in, /* condition code register */
        input wire [1:0] opcode_in, /* ALU opcode */
        output reg [15:0] q_out, /* ALU result */
        output reg carry_out,
        output reg overflow_out
        );
always @(*)
        begin
                case (opcode_in)
                        2'b00: { carry_out, q_out } = { 1'b0, a_in } + { 1'b0, b_in }; // ADD
                        2'b01: { carry_out, q_out } = { 1'b0, a_in } - { 1'b0, b_in }; // SUB
                        2'b10: { carry_out, q_out } = { 1'b0, a_in } + { 1'b0, b_in } + { 8'h0, carry_in }; // ADC
                        2'b11: { carry_out, q_out } = { 1'b0, a_in } - { 1'b0, b_in } - { 8'h0, carry_in }; // SBC
                endcase
        end
 
always @(*)
        begin
                case (opcode_in)
                        2'b00, 2'b10: overflow_out = (a_in[15] & b_in[15] & (~q_out[15])) | ((~a_in[15]) & (~b_in[15]) & q_out[15]);
                        2'b01, 2'b11: overflow_out = (a_in[15] & (~b_in[15]) & (~q_out[15])) | ((~a_in[15]) & b_in[15] & q_out[15]);
                endcase
        end
 
endmodule
 
module shift8(
        input wire [7:0] a_in,
        input wire [7:0] b_in,
        input wire carry_in, /* condition code register */
        input wire overflow_in, /* condition code register */
        input wire [2:0] opcode_in, /* ALU opcode */
        output reg [7:0] q_out, /* ALU result */
        output wire carry_out,
        output reg overflow_out
        );
 
always @(*)
        begin
                q_out = { a_in[7], a_in[7:1] }; // ASR
                case (opcode_in)
                        3'b000: q_out = { 1'b0, a_in[7:1] }; // LSR
                        3'b001: q_out = { a_in[6:0], 1'b0 }; // LSL
                        3'b010: q_out = { carry_in, a_in[7:1] }; // ROR
                        3'b011: q_out = { a_in[6:0], carry_in }; // ROL
                        3'b100: q_out = { a_in[7], a_in[7:1] }; // ASR
                endcase
        end
 
always @(*)
        begin
                overflow_out = overflow_in;
                case (opcode_in)
                        3'b000: overflow_out = overflow_in; // LSR
                        3'b001: overflow_out = a_in[7] ^ a_in[6]; // LSL
                        3'b010: overflow_out = overflow_in; // ROR
                        3'b011: overflow_out = a_in[7] ^ a_in[6]; // ROL
                        3'b100: overflow_out = overflow_in; // ASR
                endcase
        end
 
assign carry_out = opcode_in[0] ? a_in[7]:a_in[0];
 
endmodule
 
 
module alu8(
        input wire clk_in,
        input wire [7:0] a_in,
        input wire [7:0] b_in,
        input wire [7:0] CCR, /* condition code register */
        input wire [4:0] opcode_in, /* ALU opcode */
        output reg [7:0] q_out, /* ALU result */
        output reg [7:0] CCRo
        );
 
wire c_in, n_in, v_in, z_in, h_in;
assign c_in = CCR[0]; /* carry flag */
assign n_in = CCR[3]; /* neg flag */
assign v_in = CCR[1]; /* overflow flag */
assign z_in = CCR[2]; /* zero flag */
assign h_in = CCR[5]; /* halb-carry flag */
 
wire [7:0] com8_r, neg8_r, daa_p0_r;
wire [3:0] daa8h_r;
 
wire [7:0] com8_w, neg8_w;
 
wire ccom8_r, cneg8_r, cdaa8_r;
 
wire vcom8_r, vneg8_r;
 
assign com8_w = ~a_in[7:0];
assign neg8_w = 8'h0 - a_in[7:0];
                // COM
assign com8_r = com8_w;
assign ccom8_r = com8_w != 8'h0 ? 1'b1:1'b0;
assign vcom8_r = 1'b0;
                // NEG
assign neg8_r = neg8_w;
assign cneg8_r = neg8_w[7] | neg8_w[6] | neg8_w[5] | neg8_w[4] | neg8_w[3] | neg8_w[2] | neg8_w[1] | neg8_w[0];
assign vneg8_r = neg8_w[7] & (~neg8_w[6]) & (~neg8_w[5]) & (~neg8_w[4]) & (~neg8_w[3]) & (~neg8_w[2]) & (~neg8_w[1]) & (~neg8_w[0]);
 
reg c8, h8, v8;
reg [7:0] q8;
 
wire [7:0] logic_q, arith_q, shift_q;
wire arith_c, arith_v, arith_h;
wire shift_c, shift_v;
 
reg [7:0] alu8_b_in;
 
always @(*)
        begin
        alu8_b_in = b_in[7:0];
        case (opcode_in)
            `INC, `DEC: alu8_b_in = 8'h01;
            `CLR: alu8_b_in = 8'h0;
        endcase
    end
 
logic8 l8(a_in, b_in, opcode_in[1:0], logic_q);
arith8 a8(a_in, alu8_b_in, c_in, h_in, opcode_in[1:0], arith_q, arith_c, arith_v, arith_h);
shift8 s8(a_in, b_in, c_in, v_in, opcode_in[2:0], shift_q, shift_c, shift_v);
                // DAA
assign daa_p0_r = ((a_in[3:0] > 4'h9) | h_in ) ? a_in[7:0] + 8'h6:a_in[7:0];
assign { cdaa8_r, daa8h_r } = ((daa_p0_r[7:4] > 9) || (c_in == 1'b1)) ? { 1'b0, daa_p0_r[7:4] } + 5'h6:{ 1'b0, daa_p0_r[7:4] };
 
always @(*)
        begin
                q8 = 8'h0;
                c8 = c_in;
                h8 = h_in;
                v8 = v_in;
                case (opcode_in)
                        `SEXT:
                                begin
                                        q8 = a_in[7] ? 8'hff:8'h00;
                                end
                        `ADD, `ADC, `SUB, `SBC:
                                begin
                                        q8 = arith_q;
                                        c8 = arith_c;
                                        v8 = arith_v;
                                        h8 = arith_h;
                                end
                        `DEC, `INC:
                                begin
                                        q8 = arith_q;
                                        v8 = arith_v;
                                end
                        `COM:
                                begin
                                        q8 = com8_r;
                                        c8 = com8_r;
                                        v8 = vcom8_r;
                                end
                        `NEG:
                                begin
                                        q8 = neg8_r;
                                        c8 = cneg8_r;
                                        v8 = vneg8_r;
                                end
                        `LSR, `LSL, `ROL, `ROR,`ASR:
                                begin
                                        q8 = shift_q;
                                        c8 = shift_c;
                                        v8 = shift_v;
                                end
                        `AND, `OR, `EOR, `LD:
                                begin
                                        q8 = logic_q;
                                        v8 = 1'b0;
                                        end
                        `TST:
                                begin
                                        q8 = a_in;
                                        v8 = 1'b0;
                                        end
                        `DAA:
                                begin // V is undefined, so we don't touch it
                                        q8 = { daa8h_r, daa_p0_r[3:0] };
                                        c8 = cdaa8_r;
                                end
                        `ST:
                                begin
                                        q8 = a_in[7:0];
                                end
                endcase
        end
/*
reg [7:0] regq8;
// register before second mux
always @(posedge clk_in)
        begin
                regq8 <= q8;
        end
*/
always @(*)
        begin
                q_out[7:0] = q8; //regq8;
        //          e, f   h    i       n      z            v   c
                CCRo = { CCR[7:6], h8, CCR[4], q8[7], (q8 == 8'h0), v8, c8 };
        end
 
initial
        begin
        end
endmodule
 
/* ALU for 16 bit operations */
module alu16(
        input wire clk_in,
        input wire [15:0] a_in,
        input wire [15:0] b_in,
        input wire [7:0] CCR, /* condition code register */
        input wire [4:0] opcode_in, /* ALU opcode */
        input wire [15:0] q_mul_in,
        output reg [15:0] q_out, /* ALU result */
        output reg [3:0] CCRo
        );
 
wire c_in, n_in, v_in, z_in;
assign c_in = CCR[0]; /* carry flag */
assign n_in = CCR[3]; /* neg flag */
assign v_in = CCR[1]; /* overflow flag */
assign z_in = CCR[2]; /* zero flag */
 
`ifdef HD6309
wire [15:0] com16_r, neg16_r;
wire [15:0] asr16_r, shr16_r, shl16_r, ror16_r, rol16_r, and16_r, or16_r, eor16_r;
 
wire [15:0] com16_w, neg16_w;
wire [15:0] asr16_w, shr16_w, shl16_w, ror16_w, rol16_w, and16_w, or16_w, eor16_w;
 
wire ccom16_r, cneg16_r;
wire casr16_r, cshr16_r, cshl16_r, cror16_r, crol16_r, cand16_r;
 
wire vadd16_r, vadc16_r, vsub16_r, vsbc16_r, vcom16_r, vneg16_r;
wire vasr16_r, vshr16_r, vshl16_r, vror16_r, vrol16_r, vand16_r;
 
assign com16_w = ~a_in[15:0];
assign neg16_w = 16'h0 - a_in[15:0];
assign asr16_w = { a_in[15], a_in[15:1] };
assign shr16_w = { 1'b0, a_in[15:1] };
assign shl16_w = { a_in[14:0], 1'b0 };
assign ror16_w = { c_in, a_in[15:1] };
assign rol16_w = { a_in[14:0], c_in };
assign and16_w = a_in[15:0] & b_in[15:0];
assign or16_w = a_in[15:0] | b_in[15:0];
assign eor16_w = a_in[15:0] ^ b_in[15:0];
 
// COM
assign com16_r = com16_w;
assign ccom16_r = com16_w != 16'h0 ? 1'b1:1'b0;
assign vcom16_r = 1'b0;
                // NEG
assign neg16_r = neg16_w;
assign vneg16_r = neg16_w[15] & (~neg16_w[14]) & (~neg16_w[13]) & (~neg16_w[12]) & (~neg16_w[11]) & (~neg16_w[10]) & (~neg16_w[9]) & (~neg16_w[8]) & (~neg16_w[7]) & (~neg16_w[6]) & (~neg16_w[5]) & (~neg16_w[4]) & (~neg16_w[3]) & (~neg16_w[2]) & (~neg16_w[1]) & (~neg16_w[0]);
assign cneg16_r = neg16_w[15] | neg16_w[14] | neg16_w[13] | neg16_w[12] | neg16_w[11] | neg16_w[10] | neg16_w[9] & neg16_w[8] | neg16_w[7] | neg16_w[6] | neg16_w[5] | neg16_w[4] | neg16_w[3] | neg16_w[2] | neg16_w[1] | neg16_w[0];
                // ASR
assign asr16_r = asr16_w;
assign casr16_r = a_in[0];
assign vasr16_r = a_in[0] ^ asr16_w[15];
                // SHR
assign shr16_r = shr16_w;
assign cshr16_r = a_in[0];
assign vshr16_r = a_in[0] ^ shr16_w[15];
                // SHL
assign shl16_r = shl16_w;
assign cshl16_r = a_in[15];
assign vshl16_r = a_in[15] ^ shl16_w[15];
                // ROR
assign ror16_r = ror16_w;
assign cror16_r = a_in[0];
assign vror16_r = a_in[0] ^ ror16_w[15];
                // ROL
assign rol16_r = rol16_w;
assign crol16_r = a_in[15];
assign vrol16_r = a_in[15] ^ rol16_w[15];
                // AND
assign and16_r = and16_w;
assign cand16_r = c_in;
assign vand16_r = 1'b0;
                // OR
assign or16_r = or16_w;
                // EOR
assign eor16_r = eor16_w;
`endif
 
reg c16, n16, v16, z16;
reg [15:0] q16;
 
wire [15:0] arith_q;
wire arith_c, arith_v;
 
arith16 a16(a_in, b_in, c_in, opcode_in[1:0], arith_q, arith_c, arith_v);
 
always @(*)
        begin
                q16 = 16'h0;
                c16 = c_in;
                v16 = v_in;
                case (opcode_in)
                        `ADD, `ADC, `SUB, `SBC:
                                begin
                                        q16 = arith_q;
                                        c16 = arith_c;
                                        v16 = arith_v;
                                end
`ifdef HD6309
                        `COM:
                                begin
                                        q16 = com16_r;
                                        c16 = ccom16_r;
                                        v16 = vcom16_r;
                                end
                        `NEG:
                                begin
                                        q16 = neg16_r;
                                        c16 = cneg16_r;
                                        v16 = vneg16_r;
                                end
                        `ASR:
                                begin
                                        q16 = asr16_r;
                                        c16 = casr16_r;
                                        v16 = vasr16_r;
                                end
                        `LSR:
                                begin
                                        q16 = shr16_r;
                                        c16 = cshr16_r;
                                        v16 = vshr16_r;
                                end
                        `LSL:
                                begin
                                        q16 = shl16_r;
                                        c16 = cshl16_r;
                                        v16 = vshl16_r;
                                end
                        `ROR:
                                begin
                                        q16 = ror16_r;
                                        c16 = cror16_r;
                                        v16 = vror16_r;
                                end
                        `ROL:
                                begin
                                        q16 = rol16_r;
                                        c16 = crol16_r;
                                        v16 = vrol16_r;
                                end
                        `AND:
                                begin
                                        q16 = and16_r;
                                        c16 = cand16_r;
                                        v16 = vand16_r;
                                        end
                        `OR:
                                begin
                                        q16 = or16_r;
                                        c16 = cand16_r;
                                        v16 = vand16_r;
                                end
                        `EOR:
                                begin
                                        q16 = eor16_r;
                                        c16 = cand16_r;
                                        v16 = vand16_r;
                                end
`endif
                        `MUL:
                                begin
                                        q16 = q_mul_in;
                                        c16 = q_mul_in[7];
                                end
                        `LD:
                                begin
                                        v16 = 0;
                                        q16 = b_in[15:0];
                                end
                        `ST:
                                begin
                                        q16 = a_in[15:0];
                                end
                        `SEXT: // sign extend
                                begin
                                        q16 = { b_in[7] ? 8'hff:8'h00, b_in[7:0] };
                                end
                        `LEA:
                                begin
                                        q16 = a_in[15:0];
                                end
                endcase
        end
 
reg reg_n_in, reg_z_in;
/* register before second mux */
always @(posedge clk_in)
        begin
                reg_n_in <= n_in;
                reg_z_in <= z_in;
        end
 
/* Negative & zero flags */
always @(*)
        begin
                n16 = q16[15];
                z16 = q16 == 16'h0;
                case (opcode_in)
                        `ADD:
                                begin
                                end
                        `ADC:
                                begin
                                end
                        `SUB: // for CMP no register result is written back
                                begin
                                end
                        `SBC:
                                begin
                                end
                        `COM:
                                begin
                                end
                        `NEG:
                                begin
                                end
                        `ASR:
                                begin
                                end
                        `LSR:
                                begin
                                end
                        `LSL:
                                begin
                                end
                        `ROR:
                                begin
                                end
                        `ROL:
                                begin
                                end
                        `AND:
                                begin
                                end
                        `OR:
                                begin
                                end
                        `EOR:
                                begin
                                end
                        `MUL:
                                begin
                                        n16 = reg_n_in;
                                end
                        `LD:
                                begin
                                end
                        `ST:
                                begin
                                end
                        `SEXT: // sign extend
                                begin
                                        n16 = reg_n_in;
                                        z16 = reg_z_in;
                                end
                        `LEA: // only Z will be affected
                                begin
                                        n16 = reg_n_in;
                                end
                endcase
        end
 
 
always @(*)
        begin
                q_out = q16;
                CCRo = { n16, z16, v16, c16 };
        end
 
endmodule
 
module mul8x8(
        input wire clk_in,
        input wire [7:0] a,
        input wire [7:0] b,
        output wire [15:0] q
        );
 
reg [15:0] pipe0, pipe1;//, pipe2, pipe3;
assign q = pipe1;
 
always @(posedge clk_in)
        begin
                pipe0 <= (a[0] ? {8'h0, b}:16'h0) + (a[1] ? { 7'h0, b, 1'h0}:16'h0) +
                         (a[2] ? {6'h0, b, 2'h0}:16'h0) + (a[3] ? { 5'h0, b, 3'h0}:16'h0);
                pipe1 <= (a[4] ? {4'h0, b, 4'h0}:16'h0) + (a[5] ? { 3'h0, b, 5'h0}:16'h0) +
                         (a[6] ? {2'h0, b, 6'h0}:16'h0) + (a[7] ? { 1'h0, b, 7'h0}:16'h0) + pipe0;
                /*
                pipe0 <= (a[0] ? {8'h0, b}:16'h0) + (a[1] ? { 7'h0, b, 1'h0}:16'h0);
                pipe1 <= (a[2] ? {6'h0, b, 2'h0}:16'h0) + (a[3] ? { 5'h0, b, 3'h0}:16'h0) + pipe0;
                pipe2 <= (a[4] ? {4'h0, b, 4'h0}:16'h0) + (a[5] ? { 3'h0, b, 5'h0}:16'h0) + pipe1;
                pipe3 <= (a[6] ? {2'h0, b, 6'h0}:16'h0) + (a[7] ? { 1'h0, b, 7'h0}:16'h0) + pipe2;
                */
        end
 
endmodule

Line No.	Rev	Author	Line
1	4	ale500	`/*`
2			`* (c) 2013 Alejandro Paz`
3			`*`
4			`*`
5			`* An alu core`
6			`*`
7			`* ADD, ADC, DAA, SUB, SBC, COM, NEG, CMP, ASR, ASL, ROR, ROL, RCR, RCL`
8			`*`
9			`*`
10			`*`
11			`*/`
12			`include "defs.v"
13	6	ale500
14
15			`module alu(`
16			`input wire clk_in,`
17	4	ale500	`input wire [15:0] a_in,`
18			`input wire [15:0] b_in,`
19			`input wire [7:0] CCR, /* condition code register */`
20			`input wire [4:0] opcode_in, /* ALU opcode */`
21			`input wire sz_in, /* size, low 8 bit, high 16 bit */`
22			`output reg [15:0] q_out, /* ALU result */`
23			`output reg [7:0] CCRo`
24			`);`
25	2	ale500
26	6	ale500	`wire [7:0] ccr8_out, q8_out;`
27			`wire [15:0] q16_out;`
28			`wire [3:0] ccr16_out;`
29	12	ale500	`wire [15:0] q16_mul;`
30	6	ale500	`reg [15:0] ra_in, rb_in;`
31	16	ale500	`reg [4:0] rop_in;`
32
33	12	ale500	`mul8x8 mulu(clk_in, a_in[7:0], b_in[7:0], q16_mul);`
34	9	ale500	`alu8 alu8(clk_in, ra_in[7:0], rb_in[7:0], CCR, rop_in, q8_out, ccr8_out);`
35	12	ale500	`alu16 alu16(clk_in, ra_in, rb_in, CCR, rop_in, q16_mul, q16_out, ccr16_out);`
36	6	ale500
37			`always @(posedge clk_in)`
38			`begin`
39			`ra_in <= a_in;`
40			`rb_in <= b_in;`
41	9	ale500	`rop_in <= opcode_in;`
42	6	ale500	`end`
43
44			`always @(*)`
45			`begin`
46			`if (sz_in)`
47			`begin`
48			`q_out = q16_out;`
49			`CCRo = { CCR[7:4], ccr16_out };`
50			`end`
51			`else`
52			`begin`
53			`q_out = { 8'h0, q8_out };`
54			`CCRo = ccr8_out;`
55			`end`
56			`end`
57	9	ale500
58	6	ale500
59			`endmodule`
60	9	ale500	`/**`
61			`* Simple 3 functions logic`
62			`*`
63			`*/`
64			`module logic8(`
65			`input wire [7:0] a_in,`
66			`input wire [7:0] b_in,`
67			`input wire [1:0] opcode_in, /* ALU opcode */`
68			`output reg [7:0] q_out /* ALU result */`
69			`);`
70	6	ale500
71	9	ale500	`always @(*)`
72			`begin`
73			`case (opcode_in)`
74			`2'b00: q_out = b_in;`
75			`2'b01: q_out = a_in & b_in;`
76			`2'b10: q_out = a_in \| b_in;`
77			`2'b11: q_out = a_in ^ b_in;`
78			`endcase`
79			`end`
80
81			`endmodule`
82
83			`/**`
84			`* Simple ADD/SUB module`
85			`*`
86			`*/`
87			`module arith8(`
88			`input wire [7:0] a_in,`
89			`input wire [7:0] b_in,`
90			`input wire carry_in, /* condition code register */`
91			`input wire half_c_in,`
92			`input wire [1:0] opcode_in, /* ALU opcode */`
93			`output reg [7:0] q_out, /* ALU result */`
94			`output reg carry_out,`
95			`output reg overflow_out,`
96			`output reg half_c_out`
97			`);`
98	10	ale500
99			`wire carry;`
100			`assign carry = opcode_in[1] ? carry_in:1'b0;`
101	9	ale500
102			`always @(*)`
103			`begin`
104	10	ale500	`case (opcode_in[0])`
105			`1'b0: { carry_out, q_out } = { 1'b0, a_in } + { 1'b0, b_in } + { 8'h0, carry }; // ADD/ADC`
106			`1'b1: { carry_out, q_out } = { 1'b0, a_in } - { 1'b0, b_in } - { 8'h0, carry }; // SUB/SBC`
107	9	ale500	`endcase`
108			`end`
109
110			`always @(*)`
111			`begin`
112	10	ale500	`case (opcode_in[0])`
113			`1'b0: overflow_out = (a_in[7] & b_in[7] & (~q_out[7])) \| ((~a_in[7]) & (~b_in[7]) & q_out[7]);`
114			`1'b1: overflow_out = (a_in[7] & (~b_in[7]) & (~q_out[7])) \| ((~a_in[7]) & b_in[7] & q_out[7]);`
115	9	ale500	`endcase`
116			`end`
117
118			`always @(*)`
119			`begin`
120	10	ale500	`case (opcode_in[0])`
121	12	ale500	`1'b0: half_c_out = (a_in[4] ^ b_in[4] ^ q_out[4]);`
122	10	ale500	`1'b1: half_c_out = half_c_in;`
123	9	ale500	`endcase`
124			`end`
125
126			`endmodule`
127
128			`/**`
129			`* Simple ADD/SUB module`
130			`*`
131			`*/`
132			`module arith16(`
133			`input wire [15:0] a_in,`
134			`input wire [15:0] b_in,`
135			`input wire carry_in, /* condition code register */`
136			`input wire [1:0] opcode_in, /* ALU opcode */`
137			`output reg [15:0] q_out, /* ALU result */`
138			`output reg carry_out,`
139			`output reg overflow_out`
140			`);`
141			`always @(*)`
142			`begin`
143			`case (opcode_in)`
144			`2'b00: { carry_out, q_out } = { 1'b0, a_in } + { 1'b0, b_in }; // ADD`
145			`2'b01: { carry_out, q_out } = { 1'b0, a_in } - { 1'b0, b_in }; // SUB`
146			`2'b10: { carry_out, q_out } = { 1'b0, a_in } + { 1'b0, b_in } + { 8'h0, carry_in }; // ADC`
147			`2'b11: { carry_out, q_out } = { 1'b0, a_in } - { 1'b0, b_in } - { 8'h0, carry_in }; // SBC`
148			`endcase`
149			`end`
150
151			`always @(*)`
152			`begin`
153			`case (opcode_in)`
154	17	ale500	`2'b00, 2'b10: overflow_out = (a_in[15] & b_in[15] & (~q_out[15])) \| ((~a_in[15]) & (~b_in[15]) & q_out[15]);`
155			`2'b01, 2'b11: overflow_out = (a_in[15] & (~b_in[15]) & (~q_out[15])) \| ((~a_in[15]) & b_in[15] & q_out[15]);`
156	9	ale500	`endcase`
157			`end`
158
159			`endmodule`
160
161			`module shift8(`
162			`input wire [7:0] a_in,`
163			`input wire [7:0] b_in,`
164			`input wire carry_in, /* condition code register */`
165			`input wire overflow_in, /* condition code register */`
166			`input wire [2:0] opcode_in, /* ALU opcode */`
167			`output reg [7:0] q_out, /* ALU result */`
168			`output wire carry_out,`
169			`output reg overflow_out`
170			`);`
171
172			`always @(*)`
173			`begin`
174			`q_out = { a_in[7], a_in[7:1] }; // ASR`
175			`case (opcode_in)`
176			`3'b000: q_out = { 1'b0, a_in[7:1] }; // LSR`
177			`3'b001: q_out = { a_in[6:0], 1'b0 }; // LSL`
178			`3'b010: q_out = { carry_in, a_in[7:1] }; // ROR`
179			`3'b011: q_out = { a_in[6:0], carry_in }; // ROL`
180			`3'b100: q_out = { a_in[7], a_in[7:1] }; // ASR`
181			`endcase`
182			`end`
183
184			`always @(*)`
185			`begin`
186			`overflow_out = overflow_in;`
187			`case (opcode_in)`
188			`3'b000: overflow_out = overflow_in; // LSR`
189			`3'b001: overflow_out = a_in[7] ^ a_in[6]; // LSL`
190			`3'b010: overflow_out = overflow_in; // ROR`
191			`3'b011: overflow_out = a_in[7] ^ a_in[6]; // ROL`
192			`3'b100: overflow_out = overflow_in; // ASR`
193			`endcase`
194			`end`
195
196	12	ale500	`assign carry_out = opcode_in[0] ? a_in[7]:a_in[0];`
197	9	ale500
198			`endmodule`
199
200
201	6	ale500	`module alu8(`
202			`input wire clk_in,`
203	9	ale500	`input wire [7:0] a_in,`
204			`input wire [7:0] b_in,`
205	6	ale500	`input wire [7:0] CCR, /* condition code register */`
206			`input wire [4:0] opcode_in, /* ALU opcode */`
207			`output reg [7:0] q_out, /* ALU result */`
208			`output reg [7:0] CCRo`
209			`);`
210
211			`wire c_in, n_in, v_in, z_in, h_in;`
212			`assign c_in = CCR[0]; /* carry flag */`
213			`assign n_in = CCR[3]; /* neg flag */`
214			`assign v_in = CCR[1]; /* overflow flag */`
215			`assign z_in = CCR[2]; /* zero flag */`
216			`assign h_in = CCR[5]; /* halb-carry flag */`
217
218	12	ale500	`wire [7:0] com8_r, neg8_r, daa_p0_r;`
219			`wire [3:0] daa8h_r;`
220	6	ale500
221	9	ale500	`wire [7:0] com8_w, neg8_w;`
222	6	ale500
223	9	ale500	`wire ccom8_r, cneg8_r, cdaa8_r;`
224	6	ale500
225	9	ale500	`wire vcom8_r, vneg8_r;`
226	6	ale500
227			`assign com8_w = ~a_in[7:0];`
228			`assign neg8_w = 8'h0 - a_in[7:0];`
229			`// COM`
230			`assign com8_r = com8_w;`
231			`assign ccom8_r = com8_w != 8'h0 ? 1'b1:1'b0;`
232			`assign vcom8_r = 1'b0;`
233			`// NEG`
234			`assign neg8_r = neg8_w;`
235			`assign cneg8_r = neg8_w[7] \| neg8_w[6] \| neg8_w[5] \| neg8_w[4] \| neg8_w[3] \| neg8_w[2] \| neg8_w[1] \| neg8_w[0];`
236			`assign vneg8_r = neg8_w[7] & (~neg8_w[6]) & (~neg8_w[5]) & (~neg8_w[4]) & (~neg8_w[3]) & (~neg8_w[2]) & (~neg8_w[1]) & (~neg8_w[0]);`
237
238	18	ale500	`reg c8, h8, v8;`
239	6	ale500	`reg [7:0] q8;`
240	9	ale500
241			`wire [7:0] logic_q, arith_q, shift_q;`
242			`wire arith_c, arith_v, arith_h;`
243	16	ale500	`wire shift_c, shift_v;`
244
245			`reg [7:0] alu8_b_in;`
246
247			`always @(*)`
248			`begin`
249			`alu8_b_in = b_in[7:0];`
250			`case (opcode_in)`
251			`INC, `DEC: alu8_b_in = 8'h01;
252			`CLR: alu8_b_in = 8'h0;
253			`endcase`
254			`end`
255
256	9	ale500	`logic8 l8(a_in, b_in, opcode_in[1:0], logic_q);`
257	16	ale500	`arith8 a8(a_in, alu8_b_in, c_in, h_in, opcode_in[1:0], arith_q, arith_c, arith_v, arith_h);`
258	9	ale500	`shift8 s8(a_in, b_in, c_in, v_in, opcode_in[2:0], shift_q, shift_c, shift_v);`
259	12	ale500	`// DAA`
260			`assign daa_p0_r = ((a_in[3:0] > 4'h9) \| h_in ) ? a_in[7:0] + 8'h6:a_in[7:0];`
261			`assign { cdaa8_r, daa8h_r } = ((daa_p0_r[7:4] > 9) \|\| (c_in == 1'b1)) ? { 1'b0, daa_p0_r[7:4] } + 5'h6:{ 1'b0, daa_p0_r[7:4] };`
262	9	ale500
263	6	ale500	`always @(*)`
264			`begin`
265			`q8 = 8'h0;`
266			`c8 = c_in;`
267			`h8 = h_in;`
268			`v8 = v_in;`
269			`case (opcode_in)`
270	12	ale500	`SEXT:
271			`begin`
272			`q8 = a_in[7] ? 8'hff:8'h00;`
273			`end`
274	9	ale500	`ADD, `ADC, `SUB, `SBC:
275	6	ale500	`begin`
276	9	ale500	`q8 = arith_q;`
277			`c8 = arith_c;`
278			`v8 = arith_v;`
279			`h8 = arith_h;`
280	6	ale500	`end`
281	12	ale500	`DEC, `INC:
282			`begin`
283			`q8 = arith_q;`
284			`v8 = arith_v;`
285			`end`
286	6	ale500	`COM:
287			`begin`
288			`q8 = com8_r;`
289			`c8 = com8_r;`
290			`v8 = vcom8_r;`
291			`end`
292			`NEG:
293			`begin`
294			`q8 = neg8_r;`
295			`c8 = cneg8_r;`
296			`v8 = vneg8_r;`
297			`end`
298	9	ale500	`LSR, `LSL, `ROL, `ROR,`ASR:
299	6	ale500	`begin`
300	9	ale500	`q8 = shift_q;`
301			`c8 = shift_c;`
302			`v8 = shift_v;`
303	6	ale500	`end`
304	9	ale500	`AND, `OR, `EOR, `LD:
305	6	ale500	`begin`
306	9	ale500	`q8 = logic_q;`
307			`v8 = 1'b0;`
308	6	ale500	`end`
309	16	ale500	`TST:
310			`begin`
311			`q8 = a_in;`
312			`v8 = 1'b0;`
313			`end`
314	6	ale500	`DAA:
315			`begin // V is undefined, so we don't touch it`
316	12	ale500	`q8 = { daa8h_r, daa_p0_r[3:0] };`
317	6	ale500	`c8 = cdaa8_r;`
318			`end`
319			`ST:
320			`begin`
321			`q8 = a_in[7:0];`
322			`end`
323			`endcase`
324			`end`
325	12	ale500	`/*`
326	6	ale500	`reg [7:0] regq8;`
327	12	ale500	`// register before second mux`
328	6	ale500	`always @(posedge clk_in)`
329			`begin`
330			`regq8 <= q8;`
331			`end`
332	12	ale500	`*/`
333	6	ale500	`always @(*)`
334			`begin`
335			`q_out[7:0] = q8; //regq8;`
336	18	ale500	`// e, f h i n z v c`
337	12	ale500	`CCRo = { CCR[7:6], h8, CCR[4], q8[7], (q8 == 8'h0), v8, c8 };`
338	6	ale500	`end`
339
340			`initial`
341			`begin`
342			`end`
343			`endmodule`
344
345			`/* ALU for 16 bit operations */`
346			`module alu16(`
347			`input wire clk_in,`
348			`input wire [15:0] a_in,`
349			`input wire [15:0] b_in,`
350			`input wire [7:0] CCR, /* condition code register */`
351			`input wire [4:0] opcode_in, /* ALU opcode */`
352	12	ale500	`input wire [15:0] q_mul_in,`
353	6	ale500	`output reg [15:0] q_out, /* ALU result */`
354			`output reg [3:0] CCRo`
355			`);`
356
357			`wire c_in, n_in, v_in, z_in;`
358	2	ale500	`assign c_in = CCR[0]; /* carry flag */`
359			`assign n_in = CCR[3]; /* neg flag */`
360			`assign v_in = CCR[1]; /* overflow flag */`
361			`assign z_in = CCR[2]; /* zero flag */`
362
363	9	ale500	`ifdef HD6309
364			`wire [15:0] com16_r, neg16_r;`
365			`wire [15:0] asr16_r, shr16_r, shl16_r, ror16_r, rol16_r, and16_r, or16_r, eor16_r;`
366	2	ale500
367	9	ale500	`wire [15:0] com16_w, neg16_w;`
368	6	ale500	`wire [15:0] asr16_w, shr16_w, shl16_w, ror16_w, rol16_w, and16_w, or16_w, eor16_w;`
369	2	ale500
370	9	ale500	`wire ccom16_r, cneg16_r;`
371			`wire casr16_r, cshr16_r, cshl16_r, cror16_r, crol16_r, cand16_r;`
372	2	ale500
373			`wire vadd16_r, vadc16_r, vsub16_r, vsbc16_r, vcom16_r, vneg16_r;`
374			`wire vasr16_r, vshr16_r, vshl16_r, vror16_r, vrol16_r, vand16_r;`
375
376			`assign com16_w = ~a_in[15:0];`
377			`assign neg16_w = 16'h0 - a_in[15:0];`
378			`assign asr16_w = { a_in[15], a_in[15:1] };`
379			`assign shr16_w = { 1'b0, a_in[15:1] };`
380			`assign shl16_w = { a_in[14:0], 1'b0 };`
381			`assign ror16_w = { c_in, a_in[15:1] };`
382			`assign rol16_w = { a_in[14:0], c_in };`
383			`assign and16_w = a_in[15:0] & b_in[15:0];`
384			`assign or16_w = a_in[15:0] \| b_in[15:0];`
385			`assign eor16_w = a_in[15:0] ^ b_in[15:0];`
386
387	9	ale500	`// COM`
388	2	ale500	`assign com16_r = com16_w;`
389			`assign ccom16_r = com16_w != 16'h0 ? 1'b1:1'b0;`
390			`assign vcom16_r = 1'b0;`
391			`// NEG`
392			`assign neg16_r = neg16_w;`
393			`assign vneg16_r = neg16_w[15] & (~neg16_w[14]) & (~neg16_w[13]) & (~neg16_w[12]) & (~neg16_w[11]) & (~neg16_w[10]) & (~neg16_w[9]) & (~neg16_w[8]) & (~neg16_w[7]) & (~neg16_w[6]) & (~neg16_w[5]) & (~neg16_w[4]) & (~neg16_w[3]) & (~neg16_w[2]) & (~neg16_w[1]) & (~neg16_w[0]);`
394			`assign cneg16_r = neg16_w[15] \| neg16_w[14] \| neg16_w[13] \| neg16_w[12] \| neg16_w[11] \| neg16_w[10] \| neg16_w[9] & neg16_w[8] \| neg16_w[7] \| neg16_w[6] \| neg16_w[5] \| neg16_w[4] \| neg16_w[3] \| neg16_w[2] \| neg16_w[1] \| neg16_w[0];`
395			`// ASR`
396			`assign asr16_r = asr16_w;`
397			`assign casr16_r = a_in[0];`
398			`assign vasr16_r = a_in[0] ^ asr16_w[15];`
399			`// SHR`
400			`assign shr16_r = shr16_w;`
401			`assign cshr16_r = a_in[0];`
402			`assign vshr16_r = a_in[0] ^ shr16_w[15];`
403			`// SHL`
404			`assign shl16_r = shl16_w;`
405			`assign cshl16_r = a_in[15];`
406			`assign vshl16_r = a_in[15] ^ shl16_w[15];`
407			`// ROR`
408			`assign ror16_r = ror16_w;`
409			`assign cror16_r = a_in[0];`
410			`assign vror16_r = a_in[0] ^ ror16_w[15];`
411			`// ROL`
412			`assign rol16_r = rol16_w;`
413			`assign crol16_r = a_in[15];`
414			`assign vrol16_r = a_in[15] ^ rol16_w[15];`
415			`// AND`
416			`assign and16_r = and16_w;`
417			`assign cand16_r = c_in;`
418			`assign vand16_r = 1'b0;`
419			`// OR`
420			`assign or16_r = or16_w;`
421			`// EOR`
422			`assign eor16_r = eor16_w;`
423	9	ale500	`endif
424	2	ale500
425	6	ale500	`reg c16, n16, v16, z16;`
426	2	ale500	`reg [15:0] q16;`
427
428	9	ale500	`wire [15:0] arith_q;`
429	18	ale500	`wire arith_c, arith_v;`
430	9	ale500
431			`arith16 a16(a_in, b_in, c_in, opcode_in[1:0], arith_q, arith_c, arith_v);`
432
433	2	ale500	`always @(*)`
434			`begin`
435			`q16 = 16'h0;`
436			`c16 = c_in;`
437			`v16 = v_in;`
438			`case (opcode_in)`
439	9	ale500	`ADD, `ADC, `SUB, `SBC:
440	2	ale500	`begin`
441	9	ale500	`q16 = arith_q;`
442			`c16 = arith_c;`
443			`v16 = arith_v;`
444	2	ale500	`end`
445	6	ale500	`ifdef HD6309
446	2	ale500	`COM:
447			`begin`
448			`q16 = com16_r;`
449			`c16 = ccom16_r;`
450			`v16 = vcom16_r;`
451			`end`
452			`NEG:
453			`begin`
454			`q16 = neg16_r;`
455			`c16 = cneg16_r;`
456			`v16 = vneg16_r;`
457			`end`
458			`ASR:
459			`begin`
460			`q16 = asr16_r;`
461			`c16 = casr16_r;`
462			`v16 = vasr16_r;`
463			`end`
464			`LSR:
465			`begin`
466			`q16 = shr16_r;`
467			`c16 = cshr16_r;`
468			`v16 = vshr16_r;`
469			`end`
470			`LSL:
471			`begin`
472			`q16 = shl16_r;`
473			`c16 = cshl16_r;`
474			`v16 = vshl16_r;`
475			`end`
476			`ROR:
477			`begin`
478			`q16 = ror16_r;`
479			`c16 = cror16_r;`
480			`v16 = vror16_r;`
481			`end`
482			`ROL:
483			`begin`
484			`q16 = rol16_r;`
485			`c16 = crol16_r;`
486			`v16 = vrol16_r;`
487			`end`
488			`AND:
489			`begin`
490			`q16 = and16_r;`
491			`c16 = cand16_r;`
492			`v16 = vand16_r;`
493			`end`
494			`OR:
495			`begin`
496			`q16 = or16_r;`
497			`c16 = cand16_r;`
498			`v16 = vand16_r;`
499			`end`
500			`EOR:

Browse

Tools

Subversion Repositories 6809_6309_compatible_core

[/] [6809_6309_compatible_core/] [trunk/] [rtl/] [verilog/] [alu16.v] - Blame information for rev 18