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
46#include "medebug.h"
47#include "me4600_dio_reg.h"
48#include "me4600_di.h"
49
50
51
52
53
54
55
56
57
58static int me4600_di_io_reset_subdevice(struct me_subdevice *subdevice,
59 struct file *filep, int flags)
60{
61 me4600_di_subdevice_t *instance;
62 uint32_t mode;
63
64 PDEBUG("executed.\n");
65
66 instance = (me4600_di_subdevice_t *) subdevice;
67
68 if (flags) {
69 PERROR("Invalid flag specified.\n");
70 return ME_ERRNO_INVALID_FLAGS;
71 }
72
73 ME_SUBDEVICE_ENTER;
74
75 spin_lock(&instance->subdevice_lock);
76 spin_lock(instance->ctrl_reg_lock);
77 mode = inl(instance->ctrl_reg);
78 mode &= ~(ME4600_DIO_CTRL_BIT_MODE_2 | ME4600_DIO_CTRL_BIT_MODE_3);
79 outl(mode, instance->ctrl_reg);
80 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
81 instance->ctrl_reg - instance->reg_base, mode);
82 spin_unlock(instance->ctrl_reg_lock);
83
84 outl(0, instance->port_reg);
85 PDEBUG_REG("port_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
86 instance->port_reg - instance->reg_base, 0);
87 spin_unlock(&instance->subdevice_lock);
88
89 ME_SUBDEVICE_EXIT;
90
91 return ME_ERRNO_SUCCESS;
92}
93
94static int me4600_di_io_single_config(me_subdevice_t * subdevice,
95 struct file *filep,
96 int channel,
97 int single_config,
98 int ref,
99 int trig_chan,
100 int trig_type, int trig_edge, int flags)
101{
102 int err = ME_ERRNO_SUCCESS;
103 me4600_di_subdevice_t *instance;
104
105 PDEBUG("executed.\n");
106
107 instance = (me4600_di_subdevice_t *) subdevice;
108
109 ME_SUBDEVICE_ENTER;
110
111 switch (flags) {
112 case ME_IO_SINGLE_CONFIG_NO_FLAGS:
113 case ME_IO_SINGLE_CONFIG_DIO_BYTE:
114 if (channel == 0) {
115 if (single_config == ME_SINGLE_CONFIG_DIO_INPUT) {
116 } else {
117 PERROR("Invalid port direction specified.\n");
118 err = ME_ERRNO_INVALID_SINGLE_CONFIG;
119 }
120 } else {
121 PERROR("Invalid channel number.\n");
122 err = ME_ERRNO_INVALID_CHANNEL;
123 }
124 break;
125
126 default:
127 PERROR("Invalid flags specified.\n");
128 err = ME_ERRNO_INVALID_FLAGS;
129 }
130
131 ME_SUBDEVICE_EXIT;
132
133 return err;
134}
135
136static int me4600_di_io_single_read(me_subdevice_t * subdevice,
137 struct file *filep,
138 int channel,
139 int *value, int time_out, int flags)
140{
141 me4600_di_subdevice_t *instance;
142 int err = ME_ERRNO_SUCCESS;
143
144 PDEBUG("executed.\n");
145
146 instance = (me4600_di_subdevice_t *) subdevice;
147
148 ME_SUBDEVICE_ENTER;
149
150 switch (flags) {
151 case ME_IO_SINGLE_TYPE_DIO_BIT:
152 if ((channel >= 0) && (channel < 8)) {
153 *value = inl(instance->port_reg) & (0x1 << channel);
154 } else {
155 PERROR("Invalid bit number specified.\n");
156 err = ME_ERRNO_INVALID_CHANNEL;
157 }
158 break;
159
160 case ME_IO_SINGLE_NO_FLAGS:
161 case ME_IO_SINGLE_TYPE_DIO_BYTE:
162 if (channel == 0) {
163 *value = inl(instance->port_reg) & 0xFF;
164 } else {
165 PERROR("Invalid byte number specified.\n");
166 err = ME_ERRNO_INVALID_CHANNEL;
167 }
168 break;
169
170 default:
171 PERROR("Invalid flags specified.\n");
172 err = ME_ERRNO_INVALID_FLAGS;
173 }
174
175 ME_SUBDEVICE_EXIT;
176
177 return err;
178}
179
180static int me4600_di_query_number_channels(me_subdevice_t * subdevice,
181 int *number)
182{
183 PDEBUG("executed.\n");
184 *number = 8;
185 return ME_ERRNO_SUCCESS;
186}
187
188static int me4600_di_query_subdevice_type(me_subdevice_t * subdevice,
189 int *type, int *subtype)
190{
191 PDEBUG("executed.\n");
192 *type = ME_TYPE_DI;
193 *subtype = ME_SUBTYPE_SINGLE;
194 return ME_ERRNO_SUCCESS;
195}
196
197static int me4600_di_query_subdevice_caps(me_subdevice_t * subdevice, int *caps)
198{
199 PDEBUG("executed.\n");
200 *caps = 0;
201 return ME_ERRNO_SUCCESS;
202}
203
204me4600_di_subdevice_t *me4600_di_constructor(uint32_t reg_base,
205 spinlock_t * ctrl_reg_lock)
206{
207 me4600_di_subdevice_t *subdevice;
208 int err;
209
210 PDEBUG("executed.\n");
211
212
213 subdevice = kmalloc(sizeof(me4600_di_subdevice_t), GFP_KERNEL);
214
215 if (!subdevice) {
216 PERROR("Cannot get memory for subdevice instance.\n");
217 return NULL;
218 }
219
220 memset(subdevice, 0, sizeof(me4600_di_subdevice_t));
221
222
223 err = me_subdevice_init(&subdevice->base);
224
225 if (err) {
226 PERROR("Cannot initialize subdevice base class instance.\n");
227 kfree(subdevice);
228 return NULL;
229 }
230
231 spin_lock_init(&subdevice->subdevice_lock);
232
233 subdevice->ctrl_reg_lock = ctrl_reg_lock;
234
235
236 subdevice->port_reg = reg_base + ME4600_DIO_PORT_1_REG;
237 subdevice->ctrl_reg = reg_base + ME4600_DIO_CTRL_REG;
238#ifdef MEDEBUG_DEBUG_REG
239 subdevice->reg_base = reg_base;
240#endif
241
242
243 subdevice->base.me_subdevice_io_reset_subdevice =
244 me4600_di_io_reset_subdevice;
245 subdevice->base.me_subdevice_io_single_config =
246 me4600_di_io_single_config;
247 subdevice->base.me_subdevice_io_single_read = me4600_di_io_single_read;
248 subdevice->base.me_subdevice_query_number_channels =
249 me4600_di_query_number_channels;
250 subdevice->base.me_subdevice_query_subdevice_type =
251 me4600_di_query_subdevice_type;
252 subdevice->base.me_subdevice_query_subdevice_caps =
253 me4600_di_query_subdevice_caps;
254
255 return subdevice;
256}
257
