1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#ifndef __KERNEL__
28# define __KERNEL__
29#endif
30
31
32
33
34#include <linux/module.h>
35
36#include <linux/slab.h>
37#include <linux/spinlock.h>
38#include <asm/io.h>
39#include <linux/types.h>
40
41#include "medefines.h"
42#include "meinternal.h"
43#include "meerror.h"
44
45#include "medebug.h"
46#include "me0900_reg.h"
47#include "me0900_do.h"
48
49
50
51
52
53
54
55
56
57static int me0900_do_io_reset_subdevice(struct me_subdevice *subdevice,
58 struct file *filep, int flags)
59{
60 me0900_do_subdevice_t *instance;
61
62 PDEBUG("executed.\n");
63
64 instance = (me0900_do_subdevice_t *) subdevice;
65
66 if (flags) {
67 PERROR("Invalid flag specified.\n");
68 return ME_ERRNO_INVALID_FLAGS;
69 }
70
71 ME_SUBDEVICE_ENTER;
72
73 spin_lock(&instance->subdevice_lock);
74 outb(0xFF, instance->port_reg);
75 PDEBUG_REG("port_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
76 instance->port_reg - instance->reg_base, 0xff);
77 spin_unlock(&instance->subdevice_lock);
78
79 ME_SUBDEVICE_EXIT;
80
81 return ME_ERRNO_SUCCESS;
82}
83
84static int me0900_do_io_single_config(me_subdevice_t * subdevice,
85 struct file *filep,
86 int channel,
87 int single_config,
88 int ref,
89 int trig_chan,
90 int trig_type, int trig_edge, int flags)
91{
92 me0900_do_subdevice_t *instance;
93 int err = ME_ERRNO_SUCCESS;
94
95 PDEBUG("executed.\n");
96
97 instance = (me0900_do_subdevice_t *) subdevice;
98
99 ME_SUBDEVICE_ENTER;
100
101 spin_lock(&instance->subdevice_lock);
102 switch (flags) {
103 case ME_IO_SINGLE_CONFIG_NO_FLAGS:
104 case ME_IO_SINGLE_TYPE_DIO_BYTE:
105 if (channel == 0) {
106 if (single_config == ME_SINGLE_CONFIG_DIO_OUTPUT) {
107 } else {
108 PERROR("Invalid byte direction specified.\n");
109 err = ME_ERRNO_INVALID_SINGLE_CONFIG;
110 }
111 } else {
112 PERROR("Invalid byte number specified.\n");
113 err = ME_ERRNO_INVALID_CHANNEL;
114 }
115 break;
116
117 default:
118 PERROR("Invalid flags specified.\n");
119 err = ME_ERRNO_INVALID_FLAGS;
120 }
121 spin_unlock(&instance->subdevice_lock);
122
123 ME_SUBDEVICE_EXIT;
124
125 return err;
126}
127
128static int me0900_do_io_single_read(me_subdevice_t * subdevice,
129 struct file *filep,
130 int channel,
131 int *value, int time_out, int flags)
132{
133 me0900_do_subdevice_t *instance;
134 int err = ME_ERRNO_SUCCESS;
135
136 PDEBUG("executed.\n");
137
138 instance = (me0900_do_subdevice_t *) subdevice;
139
140 ME_SUBDEVICE_ENTER;
141
142 spin_lock(&instance->subdevice_lock);
143 switch (flags) {
144 case ME_IO_SINGLE_TYPE_DIO_BIT:
145 if ((channel >= 0) && (channel < 8)) {
146 *value = (~inb(instance->port_reg)) & (0x1 << channel);
147 } else {
148 PERROR("Invalid bit number specified.\n");
149 err = ME_ERRNO_INVALID_CHANNEL;
150 }
151 break;
152
153 case ME_IO_SINGLE_NO_FLAGS:
154 case ME_IO_SINGLE_TYPE_DIO_BYTE:
155 if (channel == 0) {
156 *value = ~inb(instance->port_reg);
157 } else {
158 PERROR("Invalid byte number specified.\n");
159 err = ME_ERRNO_INVALID_CHANNEL;
160 }
161 break;
162
163 default:
164 PERROR("Invalid flags specified.\n");
165 err = ME_ERRNO_INVALID_FLAGS;
166 }
167 spin_unlock(&instance->subdevice_lock);
168
169 ME_SUBDEVICE_EXIT;
170
171 return err;
172}
173
174static int me0900_do_io_single_write(me_subdevice_t * subdevice,
175 struct file *filep,
176 int channel,
177 int value, int time_out, int flags)
178{
179 me0900_do_subdevice_t *instance;
180 int err = ME_ERRNO_SUCCESS;
181 unsigned long state;
182
183 PDEBUG("executed.\n");
184
185 instance = (me0900_do_subdevice_t *) subdevice;
186
187 ME_SUBDEVICE_ENTER;
188
189 spin_lock(&instance->subdevice_lock);
190 switch (flags) {
191 case ME_IO_SINGLE_TYPE_DIO_BIT:
192 if ((channel >= 0) && (channel < 8)) {
193 state = inb(instance->port_reg);
194 state =
195 (!value) ? (state | (0x1 << channel)) : (state &
196 ~(0x1 <<
197 channel));
198 outb(state, instance->port_reg);
199 } else {
200 PERROR("Invalid bit number specified.\n");
201 err = ME_ERRNO_INVALID_CHANNEL;
202 }
203 break;
204
205 case ME_IO_SINGLE_NO_FLAGS:
206 case ME_IO_SINGLE_TYPE_DIO_BYTE:
207 if (channel == 0) {
208 outb(~(value), instance->port_reg);
209 } else {
210 PERROR("Invalid byte number specified.\n");
211 err = ME_ERRNO_INVALID_CHANNEL;
212 }
213 break;
214
215 default:
216 PERROR("Invalid flags specified.\n");
217 err = ME_ERRNO_INVALID_FLAGS;
218 }
219 spin_unlock(&instance->subdevice_lock);
220
221 ME_SUBDEVICE_EXIT;
222
223 return err;
224}
225
226static int me0900_do_query_number_channels(me_subdevice_t * subdevice,
227 int *number)
228{
229 PDEBUG("executed.\n");
230 *number = 8;
231 return ME_ERRNO_SUCCESS;
232}
233
234static int me0900_do_query_subdevice_type(me_subdevice_t * subdevice,
235 int *type, int *subtype)
236{
237 PDEBUG("executed.\n");
238 *type = ME_TYPE_DO;
239 *subtype = ME_SUBTYPE_SINGLE;
240 return ME_ERRNO_SUCCESS;
241}
242
243static int me0900_do_query_subdevice_caps(me_subdevice_t * subdevice, int *caps)
244{
245 PDEBUG("executed.\n");
246 *caps = 0;
247 return ME_ERRNO_SUCCESS;
248}
249
250me0900_do_subdevice_t *me0900_do_constructor(uint32_t reg_base,
251 unsigned int do_idx)
252{
253 me0900_do_subdevice_t *subdevice;
254 int err;
255
256 PDEBUG("executed.\n");
257
258
259 subdevice = kmalloc(sizeof(me0900_do_subdevice_t), GFP_KERNEL);
260
261 if (!subdevice) {
262 PERROR("Cannot get memory for subdevice instance.\n");
263 return NULL;
264 }
265
266 memset(subdevice, 0, sizeof(me0900_do_subdevice_t));
267
268
269 err = me_subdevice_init(&subdevice->base);
270
271 if (err) {
272 PERROR("Cannot initialize subdevice base class instance.\n");
273 kfree(subdevice);
274 return NULL;
275 }
276
277 spin_lock_init(&subdevice->subdevice_lock);
278
279
280 subdevice->do_idx = do_idx;
281
282
283 if (do_idx == 0) {
284 subdevice->ctrl_reg = reg_base + ME0900_CTRL_REG;
285 subdevice->port_reg = reg_base + ME0900_PORT_A_REG;
286 subdevice->enable_reg = reg_base + ME0900_WRITE_ENABLE_REG;
287 subdevice->disable_reg = reg_base + ME0900_WRITE_DISABLE_REG;
288 } else {
289 subdevice->ctrl_reg = reg_base + ME0900_CTRL_REG;
290 subdevice->port_reg = reg_base + ME0900_PORT_B_REG;
291 subdevice->enable_reg = reg_base + ME0900_WRITE_ENABLE_REG;
292 subdevice->disable_reg = reg_base + ME0900_WRITE_DISABLE_REG;
293 }
294#ifdef MEDEBUG_DEBUG_REG
295 subdevice->reg_base = reg_base;
296#endif
297
298
299 subdevice->base.me_subdevice_io_reset_subdevice =
300 me0900_do_io_reset_subdevice;
301 subdevice->base.me_subdevice_io_single_config =
302 me0900_do_io_single_config;
303 subdevice->base.me_subdevice_io_single_read = me0900_do_io_single_read;
304 subdevice->base.me_subdevice_io_single_write =
305 me0900_do_io_single_write;
306 subdevice->base.me_subdevice_query_number_channels =
307 me0900_do_query_number_channels;
308 subdevice->base.me_subdevice_query_subdevice_type =
309 me0900_do_query_subdevice_type;
310 subdevice->base.me_subdevice_query_subdevice_caps =
311 me0900_do_query_subdevice_caps;
312
313 return subdevice;
314}
315
