← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnuradio/trusty

« back to all changes in this revision

Viewing changes to usrp2/firmware/lib/hal_io.c

  • Committer: Bazaar Package Importer
  • Author(s): Kamal Mostafa
  • Date: 2010-03-13 07:46:01 UTC
  • mfrom: (2.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100313074601-zjsa893a87bozyh7
Tags: 3.2.2.dfsg-1ubuntu1
https://launchpad.net/bugs/260406
* Fix build for Ubuntu lucid (LP: #260406)
  - add binary package dep for libusrp0, libusrp2-0: adduser
  - debian/rules clean: remove pre-built Qt moc files

Show diffs side-by-side

added added

removed removed

Lines of Context:
usrp2/firmware/lib/hal_io.c
 
1
/* -*- c -*- */
 
2
/*
 
3
 * Copyright 2007,2008 Free Software Foundation, Inc.
 
4
 *
 
5
 * This program is free software: you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation, either version 3 of the License, or
 
8
 * (at your option) any later version.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
17
 */
 
18
 
 
19
// conditionalized on HAL_IO_USES_DBOARD_PINS && HAL_IO_USES_UART
 
20
 
 
21
#include "hal_io.h"
 
22
#include "memory_map.h"
 
23
#include "hal_uart.h"
 
24
#include "bool.h"
 
25
#include <stdio.h>
 
26
#include <string.h>
 
27
//#include <assert.h>
 
28
 
 
29
/*
 
30
 * ========================================================================
 
31
 *                                  GPIOS
 
32
 * ========================================================================
 
33
 */
 
34
void 
 
35
hal_gpio_set_ddr(int bank, int value, int mask)
 
36
{
 
37
  bank &= 0x1;
 
38
 
 
39
  if (bank == GPIO_TX_BANK){    // tx in top half
 
40
    value <<= 16;
 
41
    mask <<= 16;
 
42
  }
 
43
  else {
 
44
    value &= 0xffff;
 
45
    mask &= 0xffff;
 
46
  }
 
47
 
 
48
  int ei = hal_disable_ints();
 
49
  gpio_base->ddr = (gpio_base->ddr & ~mask) | (value & mask);
 
50
  hal_restore_ints(ei);
 
51
}
 
52
 
 
53
static bool
 
54
code_to_int(char code, int *val)
 
55
{
 
56
  switch(code){
 
57
  case 's':     *val = GPIO_SEL_SW;      return true;
 
58
  case 'a':     *val = GPIO_SEL_ATR;     return true;
 
59
  case '0':     *val = GPIO_SEL_DEBUG_0; return true;
 
60
  case '1':     *val = GPIO_SEL_DEBUG_1; return true;
 
61
  case '.':     
 
62
  default:
 
63
    return false;
 
64
  }
 
65
}
 
66
 
 
67
void
 
68
hal_gpio_set_sel(int bank, int bitno, char code)
 
69
{
 
70
  bank &= 0x1;
 
71
  int   t;
 
72
 
 
73
  if (!code_to_int(code, &t))
 
74
    return;
 
75
 
 
76
  int val  =   t << (2 * bitno);
 
77
  int mask = 0x3 << (2 * bitno);
 
78
 
 
79
  volatile uint32_t *sel = bank == GPIO_TX_BANK ? &gpio_base->tx_sel : &gpio_base->rx_sel;
 
80
  int ei = hal_disable_ints();
 
81
  int v = (*sel & ~mask) | (val & mask);
 
82
  *sel = v;
 
83
  hal_restore_ints(ei);
 
84
 
 
85
  if (0)
 
86
    printf("hal_gpio_set_sel(bank=%d, bitno=%d, code=%c) *sel = 0x%x\n",
 
87
           bank, bitno, code, v);
 
88
}
 
89
 
 
90
void
 
91
hal_gpio_set_sels(int bank, char *codes)
 
92
{
 
93
  //assert(strlen(codes) == 16);
 
94
 
 
95
  int val = 0;
 
96
  int mask = 0;
 
97
  int i;
 
98
 
 
99
  for (i = 15; i >= 0; i--){
 
100
    val <<= 2;
 
101
    mask <<= 2;
 
102
    int t;
 
103
    if (code_to_int(codes[i], &t)){
 
104
      val  |= t;
 
105
      mask |= 0x3;
 
106
    }
 
107
  }
 
108
 
 
109
  volatile uint32_t *sel = bank == GPIO_TX_BANK ? &gpio_base->tx_sel : &gpio_base->rx_sel;
 
110
  int ei = hal_disable_ints();
 
111
  *sel = (*sel & ~mask) | (val & mask);
 
112
  hal_restore_ints(ei);
 
113
}
 
114
 
 
115
 
 
116
/*!
 
117
 * \brief write \p value to gpio pins specified by \p mask.
 
118
 */
 
119
void
 
120
hal_gpio_write(int bank, int value, int mask)
 
121
{
 
122
  static uint32_t       _gpio_io_shadow;
 
123
 
 
124
  bank &= 0x1;
 
125
 
 
126
  if (bank == GPIO_TX_BANK){    // tx in top half
 
127
    value <<= 16;
 
128
    mask <<= 16;
 
129
  }
 
130
  else {
 
131
    value &= 0xffff;
 
132
    mask &= 0xffff;
 
133
  }
 
134
 
 
135
  //int ei = hal_disable_ints();
 
136
  _gpio_io_shadow = (_gpio_io_shadow & ~mask) | (value & mask);
 
137
  gpio_base->io = _gpio_io_shadow;
 
138
  //hal_restore_ints(ei);
 
139
}
 
140
 
 
141
 
 
142
/*!
 
143
 * \brief read GPIO bits
 
144
 */
 
145
int
 
146
hal_gpio_read(int bank)
 
147
{
 
148
  bank &= 0x1;
 
149
  int r = gpio_base->io;
 
150
  if (bank == GPIO_TX_BANK)
 
151
    r >>= 16;
 
152
 
 
153
  return r & 0xffff;
 
154
}
 
155
 
 
156
/*
 
157
 * ========================================================================
 
158
 *                              leds
 
159
 * ========================================================================
 
160
 */
 
161
 
 
162
static unsigned long leds_shadow = 0;
 
163
static unsigned long led_src_shadow = 0;
 
164
 
 
165
void 
 
166
hal_set_leds(int value, int mask)
 
167
{
 
168
  int ei = hal_disable_ints();
 
169
  leds_shadow = (leds_shadow & ~mask) | (value & mask);
 
170
  output_regs->leds = leds_shadow;
 
171
  hal_restore_ints(ei);
 
172
}
 
173
 
 
174
// Allow hardware control over leds.  1 = hardware, 0 = software
 
175
void 
 
176
hal_set_led_src(int value, int mask)
 
177
{
 
178
  int ei = hal_disable_ints();
 
179
  led_src_shadow = (led_src_shadow & ~mask) | (value & mask);
 
180
  output_regs->led_src = led_src_shadow;
 
181
  hal_restore_ints(ei);
 
182
}
 
183
 
 
184
void 
 
185
hal_toggle_leds(int mask)
 
186
{
 
187
  int ei = hal_disable_ints();
 
188
  leds_shadow ^= mask;
 
189
  output_regs->leds = leds_shadow;
 
190
  hal_restore_ints(ei);
 
191
}
 
192
 
 
193
 
 
194
// ================================================================
 
195
//                              primitives
 
196
// ================================================================
 
197
 
 
198
#if defined(HAL_IO_USES_DBOARD_PINS)
 
199
//
 
200
// Does i/o using high 9-bits of rx daughterboard pins.
 
201
//
 
202
//  1 1 1 1 1 1
 
203
//  5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 
204
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
205
// |      char     |W|             |
 
206
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
207
//
 
208
// 
 
209
// Asserts W when writing char
 
210
//
 
211
 
 
212
#define W       0x0080
 
213
 
 
214
void
 
215
hal_io_init(void)
 
216
{
 
217
  // make high 9 bits of tx daughterboard outputs
 
218
  hal_gpio_set_rx_mode(15, 7, GPIOM_OUTPUT);
 
219
 
 
220
  // and set them to zero
 
221
  hal_gpio_set_rx(0x0000, 0xff80);
 
222
}
 
223
 
 
224
void
 
225
hal_finish(void)
 
226
{
 
227
  volatile unsigned long *p = (unsigned long *) 0xC2F0;
 
228
  *p = 0;
 
229
}
 
230
 
 
231
// %c
 
232
inline int
 
233
putchar(int ch)
 
234
{
 
235
  hal_gpio_set_rx((s << 8) | W, 0xff80);
 
236
  hal_gpio_set_rx(0, 0xff80);
 
237
  return ch;
 
238
}
 
239
 
 
240
#elif defined(HAL_IO_USES_UART)
 
241
 
 
242
void
 
243
hal_io_init(void)
 
244
{
 
245
  hal_uart_init();
 
246
}
 
247
 
 
248
void
 
249
hal_finish(void)
 
250
{
 
251
}
 
252
 
 
253
// %c
 
254
inline int
 
255
putchar(int ch)
 
256
{
 
257
  hal_uart_putc(ch);
 
258
  return ch;
 
259
}
 
260
 
 
261
int
 
262
getchar(void)
 
263
{
 
264
  return hal_uart_getc();
 
265
}
 
266
 
 
267
#else   // nop all i/o
 
268
 
 
269
void
 
270
hal_io_init(void)
 
271
{
 
272
}
 
273
 
 
274
void
 
275
hal_finish(void)
 
276
{
 
277
}
 
278
 
 
279
// %c
 
280
inline int
 
281
putchar(int ch)
 
282
{
 
283
  return ch;
 
284
}
 
285
 
 
286
int
 
287
getchar(void)
 
288
{
 
289
  return EOF;
 
290
}
 
291
 
 
292
#endif
 
293
 
 
294
// ================================================================
 
295
//             (slightly) higher level functions
 
296
//
 
297
// These are here so we can inline the calls to putchar.
 
298
// The rest of the stuff was moved to nonstdio.c
 
299
// ================================================================
 
300
 
 
301
// \n
 
302
inline void 
 
303
newline(void)
 
304
{
 
305
  putchar('\n');
 
306
}
 
307
 
 
308
int
 
309
putstr(const char *s)
 
310
{
 
311
  while (*s)
 
312
    putchar(*s++);
 
313
 
 
314
  return 0;
 
315
}
 
316
 
 
317
int
 
318
puts(const char *s)
 
319
{
 
320
  putstr(s);
 
321
  putchar('\n');
 
322
  return 0;
 
323
}