← Back to branch summary

~arcachofo/simulide/1.1.0

« back to all changes in this revision

Viewing changes to src/simavr/cores/sim_tiny2313a.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_tiny2313a.c
 
1
/*
 
2
        sim_tiny2313a.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/iotn2313a.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 = "attiny2313a",
 
53
                DEFAULT_CORE(2),
 
54
 
 
55
                .init = init,
 
56
                .reset = reset,
 
57
        },
 
58
        AVR_EEPROM_DECLARE_8BIT(EEPROM_Ready_vect),
 
59
        AVR_WATCHDOG_DECLARE(WDTCR, WDT_OVERFLOW_vect),
 
60
        .extint = {
 
61
                AVR_EXTINT_TINY_DECLARE(0, 'D', 2, GIFR),
 
62
                AVR_EXTINT_TINY_DECLARE(1, 'D', 3, GIFR),
 
63
        },
 
64
        .porta = {
 
65
                .name = 'A',  .r_port = PORTA, .r_ddr = DDRA, .r_pin = PINA,
 
66
                .pcint = {
 
67
                        .enable = AVR_IO_REGBIT(GIMSK, PCIE1),
 
68
                        .raised = AVR_IO_REGBIT(GIFR, PCIF1),
 
69
                        .vector = PCINT1_vect,
 
70
                },
 
71
                .r_pcint = PCMSK1,
 
72
        },
 
73
        .portb = {
 
74
                .name = 'B',  .r_port = PORTB, .r_ddr = DDRB, .r_pin = PINB,
 
75
                .pcint = {
 
76
                        .enable = AVR_IO_REGBIT(GIMSK, PCIE0),
 
77
                        .raised = AVR_IO_REGBIT(GIFR, PCIF0),
 
78
                        .vector = PCINT0_vect,
 
79
                },
 
80
                .r_pcint = PCMSK0,
 
81
        },
 
82
        .portd = {
 
83
                .name = 'D',  .r_port = PORTD, .r_ddr = DDRD, .r_pin = PIND,
 
84
                .pcint = {
 
85
                        .enable = AVR_IO_REGBIT(GIMSK, PCIE2),
 
86
                        .raised = AVR_IO_REGBIT(GIFR, PCIF2),
 
87
                        .vector = PCINT2_vect,
 
88
                },
 
89
                .r_pcint = PCMSK2,
 
90
        },
 
91
 
 
92
        //PRUSART, upe=UPE, no reg/bit name index, no 'C' in RX/TX vector names
 
93
        AVR_UART_DECLARE(PRR, PRUSART, UPE, , ),
 
94
 
 
95
        .timer0 = {
 
96
                .name = '0',
 
97
                .disabled = AVR_IO_REGBIT(PRR,PRTIM0),
 
98
        .wgm = { AVR_IO_REGBIT( TCCR0A, WGM00 )
 
99
               , AVR_IO_REGBIT( TCCR0A, WGM01 )
 
100
               , AVR_IO_REGBIT( TCCR0B, WGM02 ) },
 
101
                .wgm_op = {
 
102
            [0] = WGM_NORMAL8(),
 
103
            [1] = WGM_FCPWM_8(),
 
104
            [2] = WGM_CTC_OC(),
 
105
            [3] = WGM_FASTPWM_8(),
 
106
            [5] = WGM_FCPWM_OC(),
 
107
            [7] = WGM_FASTPWM_OC(),
 
108
                },
 
109
                .cs = { AVR_IO_REGBIT(TCCR0B, CS00), AVR_IO_REGBIT(TCCR0B, CS01), AVR_IO_REGBIT(TCCR0B, CS02) },
 
110
        .cs_div = { 0, 0, 3 /* 8 */, 6 /* 64 */, 8 /* 256 */, 10 /* 1024 */, EXTCLK_CHOOSE, EXTCLK_CHOOSE },
 
111
                .ext_clock_pin = AVR_IO_REGBIT(PORTD, 4), /* External clock pin */
 
112
 
 
113
                .r_tcnt = TCNT0,
 
114
 
 
115
                .overflow = {
 
116
                        .enable = AVR_IO_REGBIT(TIMSK, TOIE0),
 
117
                        .raised = AVR_IO_REGBIT(TIFR, TOV0),
 
118
                        .vector = TIMER0_OVF_vect,
 
119
                },
 
120
                .comp = {
 
121
                        [AVR_TIMER_COMPA] = {
 
122
                                .r_ocr = OCR0A,
 
123
                                .com = AVR_IO_REGBITS(TCCR0A, COM0A0, 0x3),
 
124
                                .com_pin = AVR_IO_REGBIT(PORTB, 2),
 
125
                                .interrupt = {
 
126
                                        .enable = AVR_IO_REGBIT(TIMSK, OCIE0A),
 
127
                                        .raised = AVR_IO_REGBIT(TIFR, OCF0A),
 
128
                                        .vector = TIMER0_COMPA_vect,
 
129
                                },
 
130
                        },
 
131
                        [AVR_TIMER_COMPB] = {
 
132
                                .r_ocr = OCR0B,
 
133
                                .com = AVR_IO_REGBITS(TCCR0A, COM0B0, 0x3),
 
134
                                .com_pin = AVR_IO_REGBIT(PORTD, 5),
 
135
                                .interrupt = {
 
136
                                        .enable = AVR_IO_REGBIT(TIMSK, OCIE0B),
 
137
                                        .raised = AVR_IO_REGBIT(TIFR, OCF0B),
 
138
                                        .vector = TIMER0_COMPB_vect,
 
139
                                }
 
140
                        }
 
141
                },
 
142
        },
 
143
        .timer1 = {
 
144
                .name = '1',
 
145
                .disabled = AVR_IO_REGBIT(PRR,PRTIM1),
 
146
        .wgm = { AVR_IO_REGBIT( TCCR1A, WGM10 )
 
147
               , AVR_IO_REGBIT( TCCR1A, WGM11 )
 
148
               , AVR_IO_REGBIT( TCCR1B, WGM12 )
 
149
               , AVR_IO_REGBIT( TCCR1B, WGM13 ) },
 
150
                .wgm_op = {
 
151
            [0]  = WGM_NORMAL16(),
 
152
            [1]  = WGM_FCPWM_8(),
 
153
            [2]  = WGM_FCPWM_9(),
 
154
            [3]  = WGM_FCPWM_10(),
 
155
            [4]  = WGM_FASTPWM_8(),
 
156
            [6]  = WGM_FASTPWM_9(),
 
157
            [7]  = WGM_FASTPWM_10(),
 
158
            [8]  = WGM_FCPWM_IC(),
 
159
            [9]  = WGM_FCPWM_OC(),
 
160
            [10] = WGM_FCPWM_IC(),
 
161
            [11] = WGM_FCPWM_OC(),
 
162
            [12] = WGM_CTC_IC(),
 
163
            [14] = WGM_FASTPWM_IC(),
 
164
            [15] = WGM_FASTPWM_OC(),
 
165
                },
 
166
                .cs = { AVR_IO_REGBIT(TCCR1B, CS10), AVR_IO_REGBIT(TCCR1B, CS11), AVR_IO_REGBIT(TCCR1B, CS12) },
 
167
        .cs_div = { 0, 0, 3 /* 8 */, 6 /* 64 */, 8 /* 256 */, 10 /* 1024 */, EXTCLK_CHOOSE, EXTCLK_CHOOSE },
 
168
                .ext_clock_pin = AVR_IO_REGBIT(PORTD, 5), /* External clock pin */
 
169
 
 
170
                .r_tcnt = TCNT1L,
 
171
                .r_icr = ICR1L,
 
172
                .r_icrh = ICR1H,
 
173
                .r_tcnth = TCNT1H,
 
174
 
 
175
                .ices = AVR_IO_REGBIT(TCCR1B, ICES1),
 
176
                .icp = AVR_IO_REGBIT(PORTD, 6),
 
177
 
 
178
                .overflow = {
 
179
                        .enable = AVR_IO_REGBIT(TIMSK, TOIE1),
 
180
                        .raised = AVR_IO_REGBIT(TIFR, TOV1),
 
181
                        .vector = TIMER1_OVF_vect,
 
182
                },
 
183
                .icr = {
 
184
                        .enable = AVR_IO_REGBIT(TIMSK, ICIE1),
 
185
                        .raised = AVR_IO_REGBIT(TIFR, ICF1),
 
186
                        .vector = TIMER1_CAPT_vect,
 
187
                },
 
188
                .comp = {
 
189
                        [AVR_TIMER_COMPA] = {
 
190
                                .r_ocr = OCR1AL,
 
191
                                .r_ocrh = OCR1AH,       // 16 bits timers have two bytes of it
 
192
                                .com = AVR_IO_REGBITS(TCCR1A, COM1A0, 0x3),
 
193
                                .com_pin = AVR_IO_REGBIT(PORTB, 3),
 
194
                                .interrupt = {
 
195
                                        .enable = AVR_IO_REGBIT(TIMSK, OCIE1A),
 
196
                                        .raised = AVR_IO_REGBIT(TIFR, OCF1A),
 
197
                                        .vector = TIMER1_COMPA_vect,
 
198
                                },
 
199
                        },
 
200
                        [AVR_TIMER_COMPB] = {
 
201
                                .r_ocr = OCR1BL,
 
202
                                .r_ocrh = OCR1BH,
 
203
                                .com = AVR_IO_REGBITS(TCCR1A, COM1A0, 0x3),
 
204
                                .com_pin = AVR_IO_REGBIT(PORTB, 4),
 
205
                                .interrupt = {
 
206
                                        .enable = AVR_IO_REGBIT(TIMSK, OCIE1B),
 
207
                                        .raised = AVR_IO_REGBIT(TIFR, OCF1B),
 
208
                                        .vector = TIMER1_COMPB_vect,
 
209
                                }
 
210
                        }
 
211
                }
 
212
        },
 
213
 
 
214
        .acomp = {
 
215
                .r_acsr = ACSR,
 
216
                .acis = { AVR_IO_REGBIT(ACSR, ACIS0), AVR_IO_REGBIT(ACSR, ACIS1) },
 
217
                .acic = AVR_IO_REGBIT(ACSR, ACIC),
 
218
                .aco = AVR_IO_REGBIT(ACSR, ACO),
 
219
                .acbg = AVR_IO_REGBIT(ACSR, ACBG),
 
220
                .disabled = AVR_IO_REGBIT(ACSR, ACD),
 
221
 
 
222
                .timer_name = '1',
 
223
 
 
224
                .ac = {
 
225
                        .enable = AVR_IO_REGBIT(ACSR, ACIE),
 
226
                        .raised = AVR_IO_REGBIT(ACSR, ACI),
 
227
                        .vector = ANA_COMP_vect,
 
228
                }
 
229
        },
 
230
 
 
231
};
 
232
 
 
233
static avr_t * make()
 
234
{
 
235
        return avr_core_allocate(&mcu.core, sizeof(struct mcu_t));
 
236
}
 
237
 
 
238
avr_kind_t tiny2313a = {
 
239
        .names = { "attiny2313a" },
 
240
        .make = make
 
241
};
 
242
 
 
243
static void init(struct avr_t * avr)
 
244
{
 
245
        struct mcu_t * mcu = (struct mcu_t*)avr;
 
246
 
 
247
        avr_eeprom_init(avr, &mcu->eeprom);
 
248
        avr_watchdog_init(avr, &mcu->watchdog);
 
249
        avr_extint_init(avr, &mcu->extint);
 
250
        avr_ioport_init(avr, &mcu->porta);
 
251
        avr_ioport_init(avr, &mcu->portb);
 
252
        avr_ioport_init(avr, &mcu->portd);
 
253
        avr_uart_init(avr, &mcu->uart);
 
254
        avr_timer_init(avr, &mcu->timer0);
 
255
        avr_timer_init(avr, &mcu->timer1);
 
256
        avr_acomp_init(avr, &mcu->acomp);
 
257
}
 
258
 
 
259
static void reset(struct avr_t * avr)
 
260
{
 
261
//      struct mcu_t * mcu = (struct mcu_t*)avr;
 
262
}
 
263