IEEE 802.15.4 subsystem
Sign in or create your account | Project List | Help
IEEE 802.15.4 subsystem Git Source Tree
Root/
Source at commit e73ca5fcd5514be78554c563580501798523bd47 created 13 years 1 month ago. By Werner Almesberger, tools/lib: cache chip ID in the descriptor | |
---|---|
1 | /* |
2 | * lib/atrf.c - ATRF access functions library |
3 | * |
4 | * Written 2010-2011 by Werner Almesberger |
5 | * Copyright 2010-2011 Werner Almesberger |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify |
8 | * it under the terms of the GNU General Public License as published by |
9 | * the Free Software Foundation; either version 2 of the License, or |
10 | * (at your option) any later version. |
11 | */ |
12 | |
13 | |
14 | #include <stdlib.h> |
15 | #include <stdio.h> |
16 | |
17 | #include "at86rf230.h" |
18 | |
19 | #include "driver.h" |
20 | #include "atrf.h" |
21 | |
22 | |
23 | extern struct atrf_driver atusb_driver; |
24 | extern struct atrf_driver atben_driver; |
25 | |
26 | |
27 | struct atrf_dsc { |
28 | struct atrf_driver *driver; |
29 | void *handle; |
30 | enum atrf_chip_id chip_id; |
31 | }; |
32 | |
33 | |
34 | void *atrf_usb_handle(struct atrf_dsc *dsc) |
35 | { |
36 | #ifdef HAVE_USB |
37 | return dsc->handle; |
38 | #else |
39 | return NULL; |
40 | #endif |
41 | } |
42 | |
43 | |
44 | int atrf_error(struct atrf_dsc *dsc) |
45 | { |
46 | return dsc->driver->error ? dsc->driver->error(dsc->handle) : 0; |
47 | } |
48 | |
49 | |
50 | int atrf_clear_error(struct atrf_dsc *dsc) |
51 | { |
52 | return dsc->driver->clear_error ? |
53 | dsc->driver->clear_error(dsc->handle) : 0; |
54 | } |
55 | |
56 | |
57 | static enum atrf_chip_id identify(struct atrf_dsc *dsc) |
58 | { |
59 | uint8_t part, version; |
60 | |
61 | part = atrf_reg_read(dsc, REG_PART_NUM); |
62 | version = atrf_reg_read(dsc, REG_VERSION_NUM); |
63 | switch (part) { |
64 | case 2: /* AT86RF230 */ |
65 | switch (version) { |
66 | case 1: /* rev A */ |
67 | case 2: /* rev B */ |
68 | return artf_at86rf230; |
69 | default: |
70 | return atrf_unknown_chip; |
71 | } |
72 | break; |
73 | case 3: /* AT86RF231 */ |
74 | switch (version) { |
75 | case 2: /* rev A */ |
76 | return artf_at86rf231; |
77 | default: |
78 | return atrf_unknown_chip; |
79 | } |
80 | break; |
81 | default: |
82 | return atrf_unknown_chip; |
83 | } |
84 | return atrf_unknown_chip; |
85 | } |
86 | |
87 | |
88 | struct atrf_dsc *atrf_open(void) |
89 | { |
90 | struct atrf_dsc *dsc; |
91 | struct atrf_driver *driver; |
92 | void *handle; |
93 | |
94 | #ifdef HAVE_USB |
95 | driver = &atusb_driver; |
96 | #elif HAVE_BEN |
97 | driver = &atben_driver; |
98 | #else |
99 | #error Need either HAVE_USB or HAVE_BEN |
100 | #endif |
101 | handle = driver->open(); |
102 | if (!handle) |
103 | return NULL; |
104 | dsc = malloc(sizeof(*dsc)); |
105 | if (!dsc) { |
106 | perror("malloc"); |
107 | exit(1); |
108 | } |
109 | dsc->driver = driver; |
110 | dsc->handle = handle; |
111 | dsc->chip_id = identify(dsc); |
112 | return dsc; |
113 | } |
114 | |
115 | |
116 | void atrf_close(struct atrf_dsc *dsc) |
117 | { |
118 | if (dsc->driver->close) |
119 | dsc->driver->close(dsc->handle); |
120 | free(dsc); |
121 | } |
122 | |
123 | |
124 | void atrf_reset(struct atrf_dsc *dsc) |
125 | { |
126 | if (dsc->driver->reset) |
127 | dsc->driver->reset(dsc->handle); |
128 | } |
129 | |
130 | |
131 | void atrf_reset_rf(struct atrf_dsc *dsc) |
132 | { |
133 | dsc->driver->reset_rf(dsc->handle); |
134 | } |
135 | |
136 | |
137 | enum atrf_chip_id atrf_identify(struct atrf_dsc *dsc) |
138 | { |
139 | return dsc->chip_id; |
140 | } |
141 | |
142 | |
143 | int atrf_test_mode(struct atrf_dsc *dsc) |
144 | { |
145 | if (!dsc->driver->test_mode) |
146 | return 0; |
147 | dsc->driver->test_mode(dsc->handle); |
148 | return 1; |
149 | } |
150 | |
151 | |
152 | void atrf_reg_write(struct atrf_dsc *dsc, uint8_t reg, uint8_t value) |
153 | { |
154 | dsc->driver->reg_write(dsc->handle, reg, value); |
155 | } |
156 | |
157 | |
158 | uint8_t atrf_reg_read(struct atrf_dsc *dsc, uint8_t reg) |
159 | { |
160 | return dsc->driver->reg_read(dsc->handle, reg); |
161 | } |
162 | |
163 | |
164 | void atrf_buf_write(struct atrf_dsc *dsc, const void *buf, int size) |
165 | { |
166 | dsc->driver->buf_write(dsc->handle, buf, size); |
167 | } |
168 | |
169 | |
170 | int atrf_buf_read(struct atrf_dsc *dsc, void *buf, int size) |
171 | { |
172 | return dsc->driver->buf_read(dsc->handle, buf, size); |
173 | } |
174 | |
175 | |
176 | int atrf_interrupt(struct atrf_dsc *dsc) |
177 | { |
178 | return |
179 | dsc->driver->interrupt ? dsc->driver->interrupt(dsc->handle) : 1; |
180 | } |
181 |