← Back to branch summary

~arcachofo/simulide/1.1.0

« back to all changes in this revision

Viewing changes to src/simavr/cores/sim_tiny2313.c

  • Committer: arcachofo
  • Date: 2021-01-01 14:23:42 UTC
  • Revision ID: arcachofo@simulide.com-20210101142342-ozfljnll44g5lbl3
Initial Commit 0.5.15-RC3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/simavr/cores/sim_tiny2313.c
 
1
/*
 
2
        sim_tiny2313.c
 
3
 
 
4
        Copyright 2008, 2009 Michel Pollet <buserror@gmail.com>
 
5
 
 
6
        This file is part of simavr.
 
7
 
 
8
        simavr is free software: you can redistribute it and/or modify
 
9
        it under the terms of the GNU General Public License as published by
 
10
        the Free Software Foundation, either version 3 of the License, or
 
11
        (at your option) any later version.
 
12
 
 
13
        simavr is distributed in the hope that it will be useful,
 
14
        but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
        GNU General Public License for more details.
 
17
 
 
18
        You should have received a copy of the GNU General Public License
 
19
        along with simavr.  If not, see <http://www.gnu.org/licenses/>.
 
20
 */
 
21
 
 
22
#include "sim_core_declare.h"
 
23
#include "avr_eeprom.h"
 
24
#include "avr_watchdog.h"
 
25
#include "avr_extint.h"
 
26
#include "avr_ioport.h"
 
27
#include "avr_uart.h"
 
28
#include "avr_timer.h"
 
29
#include "avr_acomp.h"
 
30
 
 
31
static void init(struct avr_t * avr);
 
32
static void reset(struct avr_t * avr);
 
33
 
 
34
#define _AVR_IO_H_
 
35
#define __ASSEMBLER__
 
36
#include "avr/iotn2313.h"
 
37
 
 
38
/*
 
39
 * This is a template for all of the tinyx5 devices, hopefully
 
40
 */
 
41
static const struct mcu_t {
 
42
        avr_t core;
 
43
        avr_eeprom_t    eeprom;
 
44
        avr_watchdog_t  watchdog;
 
45
        avr_extint_t    extint;
 
46
        avr_ioport_t    porta, portb, portd;
 
47
        avr_uart_t              uart;
 
48
        avr_timer_t             timer0,timer1;
 
49
        avr_acomp_t             acomp;
 
50
} mcu = {
 
51
        .core = {
 
52
                .mmcu = "attiny2313",
 
53
                DEFAULT_CORE(2),
 
54
 
 
55
                .init = init,
 
56
                .reset = reset,
 
57
        },
 
58
        AVR_EEPROM_DECLARE_8BIT(EEPROM_READY_vect),
 
59
        AVR_WATCHDOG_DECLARE(WDTCSR, WDT_OVERFLOW_vect),
 
60
        .extint = {
 
61
                AVR_EXTINT_TINY_DECLARE(0, 'D', 2, EIFR),
 
62
                AVR_EXTINT_TINY_DECLARE(1, 'D', 3, EIFR),
 
63
        },
 
64
        AVR_IOPORT_DECLARE(a, 'A', A), // port A has no PCInts..
 
65
        .portb = {
 
66
                .name = 'B',  .r_port = PORTB, .r_ddr = DDRB, .r_pin = PINB,
 
67
                .pcint = {
 
68
                        .enable = AVR_IO_REGBIT(GIMSK, PCIE),
 
69
                        .raised = AVR_IO_REGBIT(EIFR, PCIF),
 
70
                        .vector = PCINT_vect,
 
71
                },
 
72
                .r_pcint = PCMSK,
 
73
        },
 
74
        AVR_IOPORT_DECLARE(d, 'D', D), // port D has no PCInts..
 
75
 
 
76
        //no PRUSART, upe=UPE, no reg/bit name index, no 'C' in RX/TX vector names
 
77
        AVR_UART_DECLARE(0, 0, UPE, , ),
 
78
 
 
79
        .timer0 = {
 
80
                .name = '0',
 
81
                .wgm = { AVR_IO_REGBIT(TCCR0A, WGM00), AVR_IO_REGBIT(TCCR0A, WGM01), AVR_IO_REGBIT(TCCR0B, WGM02) },
 
82
                .wgm_op = {
 
83
            [0] = WGM_NORMAL8(),
 
84
            [1] = WGM_FCPWM_8(),
 
85
            [2] = WGM_CTC_OC(),
 
86
            [3] = WGM_FASTPWM_8(),
 
87
            [5] = WGM_FCPWM_OC(),
 
88
            [7] = WGM_FASTPWM_OC(),
 
89
                },
 
90
                .cs = { AVR_IO_REGBIT(TCCR0B, CS00), AVR_IO_REGBIT(TCCR0B, CS01), AVR_IO_REGBIT(TCCR0B, CS02) },
 
91
        .cs_div = { 0, 0, 3 /* 8 */, 6 /* 64 */, 8 /* 256 */, 10 /* 1024 */, EXTCLK_CHOOSE, EXTCLK_CHOOSE },
 
92
                .ext_clock_pin = AVR_IO_REGBIT(PORTD, 4), /* External clock pin */
 
93
 
 
94
                .r_tcnt = TCNT0,
 
95
 
 
96
                .overflow = {
 
97
                        .enable = AVR_IO_REGBIT(TIMSK, TOIE0),
 
98
                        .raised = AVR_IO_REGBIT(TIFR, TOV0),
 
99
                        .vector = TIMER0_OVF_vect,
 
100
                },
 
101
                .comp = {
 
102
                        [AVR_TIMER_COMPA] = {
 
103
                                .r_ocr = OCR0A,
 
104
                                .com = AVR_IO_REGBITS(TCCR0A, COM0A0, 0x3),
 
105
                                .com_pin = AVR_IO_REGBIT(PORTB, 2),
 
106
                                .interrupt = {
 
107
                                        .enable = AVR_IO_REGBIT(TIMSK, OCIE0A),
 
108
                                        .raised = AVR_IO_REGBIT(TIFR, OCF0A),
 
109
                                        .vector = TIMER0_COMPA_vect,
 
110
                                },
 
111
                        },
 
112
                        [AVR_TIMER_COMPB] = {
 
113
                                .r_ocr = OCR0B,
 
114
                                .com = AVR_IO_REGBITS(TCCR0A, COM0B0, 0x3),
 
115
                                .com_pin = AVR_IO_REGBIT(PORTD, 5),
 
116
                                .interrupt = {
 
117
                                        .enable = AVR_IO_REGBIT(TIMSK, OCIE0B),
 
118
                                        .raised = AVR_IO_REGBIT(TIFR, OCF0B),
 
119
                                        .vector = TIMER0_COMPB_vect,
 
120
                                }
 
121
                        }
 
122
                },
 
123
        },
 
124
        .timer1 = {
 
125
                .name = '1',
 
126
        //      .disabled = AVR_IO_REGBIT(PRR,PRTIM1),
 
127
                .wgm = { AVR_IO_REGBIT(TCCR1A, WGM10), AVR_IO_REGBIT(TCCR1A, WGM11),
 
128
                                        AVR_IO_REGBIT(TCCR1B, WGM12), AVR_IO_REGBIT(TCCR1B, WGM13) },
 
129
                .wgm_op = {
 
130
            [0]  = WGM_NORMAL16(),
 
131
            [1]  = WGM_FCPWM_8(),
 
132
            [2]  = WGM_FCPWM_9(),
 
133
            [3]  = WGM_FCPWM_10(),
 
134
            [4]  = WGM_FASTPWM_8(),
 
135
            [6]  = WGM_FASTPWM_9(),
 
136
            [7]  = WGM_FASTPWM_10(),
 
137
            [8]  = WGM_FCPWM_IC(),
 
138
            [9]  = WGM_FCPWM_OC(),
 
139
            [10] = WGM_FCPWM_IC(),
 
140
            [11] = WGM_FCPWM_OC(),
 
141
            [12] = WGM_CTC_IC(),
 
142
            [14] = WGM_FASTPWM_IC(),
 
143
            [15] = WGM_FASTPWM_OC(),
 
144
                },
 
145
                .cs = { AVR_IO_REGBIT(TCCR1B, CS10), AVR_IO_REGBIT(TCCR1B, CS11), AVR_IO_REGBIT(TCCR1B, CS12) },
 
146
        .cs_div = { 0, 0, 3 /* 8 */, 6 /* 64 */, 8 /* 256 */, 10 /* 1024 */, EXTCLK_CHOOSE, EXTCLK_CHOOSE },
 
147
                .ext_clock_pin = AVR_IO_REGBIT(PORTD, 5), /* External clock pin */
 
148
 
 
149
                .r_tcnt = TCNT1L,
 
150
                .r_icr = ICR1L,
 
151
                .r_icrh = ICR1H,
 
152
                .r_tcnth = TCNT1H,
 
153
 
 
154
                .ices = AVR_IO_REGBIT(TCCR1B, ICES1),
 
155
                .icp = AVR_IO_REGBIT(PORTD, 6),
 
156
 
 
157
                .overflow = {
 
158
                        .enable = AVR_IO_REGBIT(TIMSK, TOIE1),
 
159
                        .raised = AVR_IO_REGBIT(TIFR, TOV1),
 
160
                        .vector = TIMER1_OVF_vect,
 
161
                },
 
162
                .icr = {
 
163
                        .enable = AVR_IO_REGBIT(TIMSK, ICIE1),
 
164
                        .raised = AVR_IO_REGBIT(TIFR, ICF1),
 
165
                        .vector = TIMER1_CAPT_vect,
 
166
                },
 
167
                .comp = {
 
168
                        [AVR_TIMER_COMPA] = {
 
169
                                .r_ocr = OCR1AL,
 
170
                                .r_ocrh = OCR1AH,       // 16 bits timers have two bytes of it
 
171
                                .com = AVR_IO_REGBITS(TCCR1A, COM1A0, 0x3),
 
172
                                .com_pin = AVR_IO_REGBIT(PORTB, 3),
 
173
                                .interrupt = {
 
174
                                        .enable = AVR_IO_REGBIT(TIMSK, OCIE1A),
 
175
                                        .raised = AVR_IO_REGBIT(TIFR, OCF1A),
 
176
                                        .vector = TIMER1_COMPA_vect,
 
177
                                },
 
178
                        },
 
179
                        [AVR_TIMER_COMPB] = {
 
180
                                .r_ocr = OCR1BL,
 
181
                                .r_ocrh = OCR1BH,
 
182
                                .com = AVR_IO_REGBITS(TCCR1A, COM1A0, 0x3),
 
183
                                .com_pin = AVR_IO_REGBIT(PORTB, 4),
 
184
                                .interrupt = {
 
185
                                        .enable = AVR_IO_REGBIT(TIMSK, OCIE1B),
 
186
                                        .raised = AVR_IO_REGBIT(TIFR, OCF1B),
 
187
                                        .vector = TIMER1_COMPB_vect,
 
188
                                }
 
189
                        }
 
190
                }
 
191
        },
 
192
 
 
193
        .acomp = {
 
194
                .r_acsr = ACSR,
 
195
                .acis = { AVR_IO_REGBIT(ACSR, ACIS0), AVR_IO_REGBIT(ACSR, ACIS1) },
 
196
                .acic = AVR_IO_REGBIT(ACSR, ACIC),
 
197
                .aco = AVR_IO_REGBIT(ACSR, ACO),
 
198
                .acbg = AVR_IO_REGBIT(ACSR, ACBG),
 
199
                .disabled = AVR_IO_REGBIT(ACSR, ACD),
 
200
 
 
201
                .timer_name = '1',
 
202
 
 
203
                .ac = {
 
204
                        .enable = AVR_IO_REGBIT(ACSR, ACIE),
 
205
                        .raised = AVR_IO_REGBIT(ACSR, ACI),
 
206
                        .vector = ANA_COMP_vect,
 
207
                }
 
208
        },
 
209
 
 
210
};
 
211
 
 
212
static avr_t * make()
 
213
{
 
214
        return avr_core_allocate(&mcu.core, sizeof(struct mcu_t));
 
215
}
 
216
 
 
217
avr_kind_t tiny2313 = {
 
218
        .names = { "attiny2313", "attiny2313v" },
 
219
        .make = make
 
220
};
 
221
 
 
222
static void init(struct avr_t * avr)
 
223
{
 
224
        struct mcu_t * mcu = (struct mcu_t*)avr;
 
225
 
 
226
        avr_eeprom_init(avr, &mcu->eeprom);
 
227
        avr_watchdog_init(avr, &mcu->watchdog);
 
228
        avr_extint_init(avr, &mcu->extint);
 
229
        avr_ioport_init(avr, &mcu->porta);
 
230
        avr_ioport_init(avr, &mcu->portb);
 
231
        avr_ioport_init(avr, &mcu->portd);
 
232
        avr_uart_init(avr, &mcu->uart);
 
233
        avr_timer_init(avr, &mcu->timer0);
 
234
        avr_timer_init(avr, &mcu->timer1);
 
235
        avr_acomp_init(avr, &mcu->acomp);
 
236
}
 
237
 
 
238
static void reset(struct avr_t * avr)
 
239
{
 
240
//      struct mcu_t * mcu = (struct mcu_t*)avr;
 
241
}
 
242