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
28#ifndef __KERNEL__
29# define __KERNEL__
30#endif
31
32
33
34
35#include <linux/module.h>
36
37#include <linux/slab.h>
38#include <linux/spinlock.h>
39#include <asm/io.h>
40#include <linux/types.h>
41
42#include "medefines.h"
43#include "meinternal.h"
44#include "meerror.h"
45#include "medebug.h"
46
47#include "me1000_dio_reg.h"
48#include "me1000_dio.h"
49
50
51
52
53#define ME1000_DIO_MAGIC_NUMBER 0x1000
54
55
56
57
58
59static int me1000_dio_io_reset_subdevice(struct me_subdevice *subdevice,
60 struct file *filep, int flags)
61{
62 me1000_dio_subdevice_t *instance;
63 uint32_t tmp;
64
65 PDEBUG("executed.\n");
66
67 instance = (me1000_dio_subdevice_t *) subdevice;
68
69 if (flags) {
70 PERROR("Invalid flag specified.\n");
71 return ME_ERRNO_INVALID_FLAGS;
72 }
73
74 ME_SUBDEVICE_ENTER;
75
76 spin_lock(&instance->subdevice_lock);
77 spin_lock(instance->ctrl_reg_lock);
78 tmp = inl(instance->ctrl_reg);
79 tmp &= ~(0x1 << instance->dio_idx);
80 outl(tmp, instance->ctrl_reg);
81 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
82 instance->ctrl_reg - instance->reg_base, tmp);
83 spin_unlock(instance->ctrl_reg_lock);
84
85 outl(0x00000000, instance->port_reg);
86 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
87 instance->ctrl_reg - instance->reg_base, 0);
88 spin_unlock(&instance->subdevice_lock);
89
90 ME_SUBDEVICE_EXIT;
91
92 return ME_ERRNO_SUCCESS;
93}
94
95static int me1000_dio_io_single_config(struct me_subdevice *subdevice,
96 struct file *filep,
97 int channel,
98 int single_config,
99 int ref,
100 int trig_chan,
101 int trig_type, int trig_edge, int flags)
102{
103 me1000_dio_subdevice_t *instance;
104 int err = ME_ERRNO_SUCCESS;
105 int ctrl;
106 int size =
107 flags & (ME_IO_SINGLE_CONFIG_DIO_BIT | ME_IO_SINGLE_CONFIG_DIO_BYTE
108 | ME_IO_SINGLE_CONFIG_DIO_WORD |
109 ME_IO_SINGLE_CONFIG_DIO_DWORD);
110
111 PDEBUG("executed.\n");
112
113 instance = (me1000_dio_subdevice_t *) subdevice;
114
115 ME_SUBDEVICE_ENTER;
116
117 spin_lock(&instance->subdevice_lock);
118 spin_lock(instance->ctrl_reg_lock);
119 ctrl = inl(instance->ctrl_reg);
120
121 switch (size) {
122 case ME_IO_SINGLE_CONFIG_NO_FLAGS:
123 case ME_IO_SINGLE_CONFIG_DIO_DWORD:
124 if (channel == 0) {
125 if (single_config == ME_SINGLE_CONFIG_DIO_INPUT) {
126 ctrl &= ~(0x1 << instance->dio_idx);
127 } else if (single_config == ME_SINGLE_CONFIG_DIO_OUTPUT) {
128 ctrl |= 0x1 << instance->dio_idx;
129 } else {
130 PERROR("Invalid port direction.\n");
131 err = ME_ERRNO_INVALID_SINGLE_CONFIG;
132 }
133 } else {
134 PERROR("Invalid channel number.\n");
135 err = ME_ERRNO_INVALID_CHANNEL;
136 }
137 break;
138
139 default:
140 PERROR("Invalid flags.\n");
141 err = ME_ERRNO_INVALID_FLAGS;
142 }
143
144 if (!err) {
145 outl(ctrl, instance->ctrl_reg);
146 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
147 instance->reg_base,
148 instance->ctrl_reg - instance->reg_base, ctrl);
149 }
150 spin_unlock(instance->ctrl_reg_lock);
151 spin_unlock(&instance->subdevice_lock);
152
153 ME_SUBDEVICE_EXIT;
154
155 return err;
156}
157
158static int me1000_dio_io_single_read(struct me_subdevice *subdevice,
159 struct file *filep,
160 int channel,
161 int *value, int time_out, int flags)
162{
163 me1000_dio_subdevice_t *instance;
164 int err = ME_ERRNO_SUCCESS;
165
166 PDEBUG("executed.\n");
167
168 instance = (me1000_dio_subdevice_t *) subdevice;
169
170 ME_SUBDEVICE_ENTER;
171
172 spin_lock(&instance->subdevice_lock);
173 switch (flags) {
174 case ME_IO_SINGLE_TYPE_DIO_BIT:
175 if ((channel >= 0) && (channel < 32)) {
176 *value = inl(instance->port_reg) & (0x1 << channel);
177 } else {
178 PERROR("Invalid bit number.\n");
179 err = ME_ERRNO_INVALID_CHANNEL;
180 }
181 break;
182
183 case ME_IO_SINGLE_TYPE_DIO_BYTE:
184 if ((channel >= 0) && (channel < 4)) {
185 *value =
186 (inl(instance->port_reg) >> (channel * 8)) & 0xFF;
187 } else {
188 PERROR("Invalid byte number.\n");
189 err = ME_ERRNO_INVALID_CHANNEL;
190 }
191 break;
192
193 case ME_IO_SINGLE_TYPE_DIO_WORD:
194 if ((channel >= 0) && (channel < 2)) {
195 *value =
196 (inl(instance->port_reg) >> (channel * 16)) &
197 0xFFFF;
198 } else {
199 PERROR("Invalid word number.\n");
200 err = ME_ERRNO_INVALID_CHANNEL;
201 }
202 break;
203
204 case ME_IO_SINGLE_NO_FLAGS:
205 case ME_IO_SINGLE_TYPE_DIO_DWORD:
206 if (channel == 0) {
207 *value = inl(instance->port_reg);
208 } else {
209 PERROR("Invalid dword number.\n");
210 err = ME_ERRNO_INVALID_CHANNEL;
211 }
212 break;
213
214 default:
215 PERROR("Invalid flags specified.\n");
216 err = ME_ERRNO_INVALID_FLAGS;
217 }
218 spin_unlock(&instance->subdevice_lock);
219
220 ME_SUBDEVICE_EXIT;
221
222 return err;
223}
224
225static int me1000_dio_io_single_write(struct me_subdevice *subdevice,
226 struct file *filep,
227 int channel,
228 int value, int time_out, int flags)
229{
230 me1000_dio_subdevice_t *instance;
231 int err = ME_ERRNO_SUCCESS;
232 uint32_t config;
233 uint32_t state;
234
235 PDEBUG("executed.\n");
236
237 instance = (me1000_dio_subdevice_t *) subdevice;
238
239 ME_SUBDEVICE_ENTER spin_lock(&instance->subdevice_lock);
240 spin_lock(instance->ctrl_reg_lock);
241 config = inl(instance->ctrl_reg) & (0x1 << instance->dio_idx);
242 switch (flags) {
243 case ME_IO_SINGLE_TYPE_DIO_BIT:
244 if ((channel >= 0) && (channel < 32)) {
245 if (config) {
246 state = inl(instance->port_reg);
247 state =
248 value ? (state | (0x1 << channel)) : (state
249 &
250 ~(0x1
251 <<
252 channel));
253 outl(state, instance->port_reg);
254 PDEBUG_REG("port_reg outl(0x%lX+0x%lX)=0x%x\n",
255 instance->reg_base,
256 instance->port_reg -
257 instance->reg_base, state);
258 } else {
259 PERROR("Port is not in output mode.\n");
260 err = ME_ERRNO_PREVIOUS_CONFIG;
261 }
262 } else {
263 PERROR("Invalid bit number.\n");
264 err = ME_ERRNO_INVALID_CHANNEL;
265 }
266 break;
267
268 case ME_IO_SINGLE_TYPE_DIO_BYTE:
269 if ((channel >= 0) && (channel < 4)) {
270 if (config) {
271 state = inl(instance->port_reg);
272 state &= ~(0xFF << (channel * 8));
273 state |= (value & 0xFF) << (channel * 8);
274 outl(state, instance->port_reg);
275 PDEBUG_REG("port_reg outl(0x%lX+0x%lX)=0x%x\n",
276 instance->reg_base,
277 instance->port_reg -
278 instance->reg_base, state);
279 } else {
280 PERROR("Port is not in output mode.\n");
281 err = ME_ERRNO_PREVIOUS_CONFIG;
282 }
283 } else {
284 PERROR("Invalid byte number.\n");
285 err = ME_ERRNO_INVALID_CHANNEL;
286 }
287 break;
288
289 case ME_IO_SINGLE_TYPE_DIO_WORD:
290 if ((channel >= 0) && (channel < 2)) {
291 if (config) {
292 state = inl(instance->port_reg);
293 state &= ~(0xFFFF << (channel * 16));
294 state |= (value & 0xFFFF) << (channel * 16);
295 outl(state, instance->port_reg);
296 PDEBUG_REG("port_reg outl(0x%lX+0x%lX)=0x%x\n",
297 instance->reg_base,
298 instance->port_reg -
299 instance->reg_base, state);
300 } else {
301 PERROR("Port is not in output mode.\n");
302 err = ME_ERRNO_PREVIOUS_CONFIG;
303 }
304 } else {
305 PERROR("Invalid word number.\n");
306 err = ME_ERRNO_INVALID_CHANNEL;
307 }
308 break;
309
310 case ME_IO_SINGLE_NO_FLAGS:
311 case ME_IO_SINGLE_TYPE_DIO_DWORD:
312 if (channel == 0) {
313 if (config) {
314 outl(value, instance->port_reg);
315 PDEBUG_REG("port_reg outl(0x%lX+0x%lX)=0x%x\n",
316 instance->reg_base,
317 instance->port_reg -
318 instance->reg_base, value);
319 } else {
320 PERROR("Port is not in output mode.\n");
321 err = ME_ERRNO_PREVIOUS_CONFIG;
322 }
323 } else {
324 PERROR("Invalid dword number.\n");
325 err = ME_ERRNO_INVALID_CHANNEL;
326 }
327 break;
328
329 default:
330 PERROR("Invalid flags specified.\n");
331 err = ME_ERRNO_INVALID_FLAGS;
332 }
333 spin_unlock(instance->ctrl_reg_lock);
334 spin_unlock(&instance->subdevice_lock);
335
336 ME_SUBDEVICE_EXIT;
337
338 return err;
339}
340
341static int me1000_dio_query_number_channels(struct me_subdevice *subdevice,
342 int *number)
343{
344 PDEBUG("executed.\n");
345 *number = ME1000_DIO_NUMBER_CHANNELS;
346 return ME_ERRNO_SUCCESS;
347}
348
349static int me1000_dio_query_subdevice_type(struct me_subdevice *subdevice,
350 int *type, int *subtype)
351{
352 PDEBUG("executed.\n");
353 *type = ME_TYPE_DIO;
354 *subtype = ME_SUBTYPE_SINGLE;
355 return ME_ERRNO_SUCCESS;
356}
357
358static int me1000_dio_query_subdevice_caps(struct me_subdevice *subdevice,
359 int *caps)
360{
361 me1000_dio_subdevice_t *instance;
362
363 PDEBUG("executed.\n");
364
365 instance = (me1000_dio_subdevice_t *) subdevice;
366
367 *caps = ME_CAPS_DIO_DIR_DWORD;
368
369 return ME_ERRNO_SUCCESS;
370}
371
372me1000_dio_subdevice_t *me1000_dio_constructor(uint32_t reg_base,
373 unsigned int dio_idx,
374 spinlock_t * ctrl_reg_lock)
375{
376 me1000_dio_subdevice_t *subdevice;
377 int err;
378
379 PDEBUG("executed.\n");
380
381
382 subdevice = kmalloc(sizeof(me1000_dio_subdevice_t), GFP_KERNEL);
383
384 if (!subdevice) {
385 PERROR("Cannot get memory for ME-1000 DIO instance.\n");
386 return NULL;
387 }
388
389 memset(subdevice, 0, sizeof(me1000_dio_subdevice_t));
390
391
392
393 if (dio_idx >= ME1000_DIO_NUMBER_PORTS) {
394 PERROR("DIO index is out of range.\n");
395 kfree(subdevice);
396 return NULL;
397 }
398
399
400 err = me_subdevice_init(&subdevice->base);
401
402 if (err) {
403 PERROR("Cannot initialize subdevice base class instance.\n");
404 kfree(subdevice);
405 return NULL;
406 }
407
408 spin_lock_init(&subdevice->subdevice_lock);
409 subdevice->ctrl_reg_lock = ctrl_reg_lock;
410
411
412 subdevice->dio_idx = dio_idx;
413
414
415#ifdef MEDEBUG_DEBUG_REG
416 subdevice->reg_base = reg_base;
417#endif
418 subdevice->ctrl_reg = reg_base + ME1000_PORT_MODE;
419 subdevice->port_reg =
420 reg_base + ME1000_PORT + (dio_idx * ME1000_PORT_STEP);
421
422
423 subdevice->base.me_subdevice_io_reset_subdevice =
424 me1000_dio_io_reset_subdevice;
425 subdevice->base.me_subdevice_io_single_config =
426 me1000_dio_io_single_config;
427 subdevice->base.me_subdevice_io_single_read = me1000_dio_io_single_read;
428 subdevice->base.me_subdevice_io_single_write =
429 me1000_dio_io_single_write;
430 subdevice->base.me_subdevice_query_number_channels =
431 me1000_dio_query_number_channels;
432 subdevice->base.me_subdevice_query_subdevice_type =
433 me1000_dio_query_subdevice_type;
434 subdevice->base.me_subdevice_query_subdevice_caps =
435 me1000_dio_query_subdevice_caps;
436
437 return subdevice;
438}
439
