Linux 2.6.31-rc6
[linux-2.6] / drivers / staging / meilhaus / me0600_dio.c
1 /**
2  * @file me0600_dio.c
3  *
4  * @brief ME-630 digital input/output subdevice instance.
5  * @note Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
6  * @author Guenter Gebhardt
7  * @author Krzysztof Gantzke    (k.gantzke@meilhaus.de)
8  */
9
10 /*
11  * Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
12  *
13  * This file is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26  */
27
28 #ifndef __KERNEL__
29 #  define __KERNEL__
30 #endif
31
32 /*
33  * Includes
34  */
35 #include <linux/module.h>
36
37 #include <linux/slab.h>
38 #include <linux/spinlock.h>
39 #include <linux/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 "me0600_dio_reg.h"
48 #include "me0600_dio.h"
49
50 /*
51  * Defines
52  */
53
54 /*
55  * Functions
56  */
57
58 static int me0600_dio_io_reset_subdevice(struct me_subdevice *subdevice,
59                                          struct file *filep, int flags)
60 {
61         me0600_dio_subdevice_t *instance;
62         uint8_t mode;
63
64         PDEBUG("executed.\n");
65
66         instance = (me0600_dio_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 = inb(instance->ctrl_reg);
78         mode &= ~(0x3 << (instance->dio_idx * 2));
79         outb(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         outb(0x00, 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, 0x00);
87         spin_unlock(&instance->subdevice_lock);
88
89         ME_SUBDEVICE_EXIT;
90
91         return ME_ERRNO_SUCCESS;
92 }
93
94 static int me0600_dio_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         me0600_dio_subdevice_t *instance;
103         int err = ME_ERRNO_SUCCESS;
104         uint8_t mode;
105         int size =
106             flags & (ME_IO_SINGLE_CONFIG_DIO_BIT | ME_IO_SINGLE_CONFIG_DIO_BYTE
107                      | ME_IO_SINGLE_CONFIG_DIO_WORD |
108                      ME_IO_SINGLE_CONFIG_DIO_DWORD);
109
110         PDEBUG("executed.\n");
111
112         instance = (me0600_dio_subdevice_t *) subdevice;
113
114         ME_SUBDEVICE_ENTER;
115
116         spin_lock(&instance->subdevice_lock);
117         spin_lock(instance->ctrl_reg_lock);
118         mode = inb(instance->ctrl_reg);
119         switch (size) {
120         case ME_IO_SINGLE_CONFIG_NO_FLAGS:
121         case ME_IO_SINGLE_CONFIG_DIO_BYTE:
122                 if (channel == 0) {
123                         if (single_config == ME_SINGLE_CONFIG_DIO_INPUT) {
124                                 mode &=
125                                     ~((ME0600_DIO_CONFIG_BIT_OUT_0) <<
126                                       (instance->dio_idx * 2));
127                         } else if (single_config == ME_SINGLE_CONFIG_DIO_OUTPUT) {
128                                 mode &=
129                                     ~((ME0600_DIO_CONFIG_BIT_OUT_0) <<
130                                       (instance->dio_idx * 2));
131                                 mode |=
132                                     ME0600_DIO_CONFIG_BIT_OUT_0 << (instance->
133                                                                     dio_idx *
134                                                                     2);
135                         } else {
136                                 PERROR
137                                     ("Invalid port configuration specified.\n");
138                                 err = ME_ERRNO_INVALID_SINGLE_CONFIG;
139                         }
140                 } else {
141                         PERROR("Invalid channel number.\n");
142                         err = ME_ERRNO_INVALID_CHANNEL;
143                 }
144                 break;
145
146         default:
147                 PERROR("Invalid flags.\n");
148                 err = ME_ERRNO_INVALID_FLAGS;
149         }
150
151         if (!err) {
152                 outb(mode, instance->ctrl_reg);
153                 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
154                            instance->reg_base,
155                            instance->ctrl_reg - instance->reg_base, mode);
156         }
157         spin_unlock(instance->ctrl_reg_lock);
158         spin_unlock(&instance->subdevice_lock);
159
160         ME_SUBDEVICE_EXIT;
161
162         return err;
163 }
164
165 static int me0600_dio_io_single_read(me_subdevice_t *subdevice,
166                                      struct file *filep,
167                                      int channel,
168                                      int *value, int time_out, int flags)
169 {
170         me0600_dio_subdevice_t *instance;
171         int err = ME_ERRNO_SUCCESS;
172         uint8_t mode;
173
174         PDEBUG("executed.\n");
175
176         instance = (me0600_dio_subdevice_t *) subdevice;
177
178         ME_SUBDEVICE_ENTER;
179
180         spin_lock(&instance->subdevice_lock);
181         spin_lock(instance->ctrl_reg_lock);
182         switch (flags) {
183         case ME_IO_SINGLE_TYPE_DIO_BIT:
184                 if ((channel >= 0) && (channel < 8)) {
185                         mode =
186                             inb(instance->
187                                 ctrl_reg) & ((ME0600_DIO_CONFIG_BIT_OUT_0) <<
188                                              (instance->dio_idx * 2));
189
190                         if ((mode ==
191                              (ME0600_DIO_CONFIG_BIT_OUT_0 <<
192                               (instance->dio_idx * 2))) || !mode) {
193                                 *value =
194                                     inb(instance->
195                                         port_reg) & (0x0001 << channel);
196                         } else {
197                                 PERROR("Port not in output or input mode.\n");
198                                 err = ME_ERRNO_PREVIOUS_CONFIG;
199                         }
200                 } else {
201                         PERROR("Invalid bit number specified.\n");
202                         err = ME_ERRNO_INVALID_CHANNEL;
203                 }
204
205                 break;
206
207         case ME_IO_SINGLE_NO_FLAGS:
208         case ME_IO_SINGLE_TYPE_DIO_BYTE:
209                 if (channel == 0) {
210                         mode =
211                             inb(instance->
212                                 ctrl_reg) & ((ME0600_DIO_CONFIG_BIT_OUT_0) <<
213                                              (instance->dio_idx * 2));
214
215                         if ((mode ==
216                              (ME0600_DIO_CONFIG_BIT_OUT_0 <<
217                               (instance->dio_idx * 2))) || !mode) {
218                                 *value = inb(instance->port_reg) & 0x00FF;
219                         } else {
220                                 PERROR("Port not in output or input mode.\n");
221                                 err = ME_ERRNO_PREVIOUS_CONFIG;
222                         }
223                 } else {
224                         PERROR("Invalid byte number specified.\n");
225                         err = ME_ERRNO_INVALID_CHANNEL;
226                 }
227
228                 break;
229
230         default:
231                 PERROR("Invalid flags specified.\n");
232
233                 err = ME_ERRNO_INVALID_FLAGS;
234
235                 break;
236         }
237         spin_unlock(instance->ctrl_reg_lock);
238         spin_unlock(&instance->subdevice_lock);
239
240         ME_SUBDEVICE_EXIT;
241
242         return err;
243 }
244
245 static int me0600_dio_io_single_write(me_subdevice_t *subdevice,
246                                       struct file *filep,
247                                       int channel,
248                                       int value, int time_out, int flags)
249 {
250         me0600_dio_subdevice_t *instance;
251         int err = ME_ERRNO_SUCCESS;
252         uint8_t mode;
253         uint8_t byte;
254
255         PDEBUG("executed.\n");
256
257         instance = (me0600_dio_subdevice_t *) subdevice;
258
259         ME_SUBDEVICE_ENTER;
260
261         spin_lock(&instance->subdevice_lock);
262         spin_lock(instance->ctrl_reg_lock);
263         switch (flags) {
264
265         case ME_IO_SINGLE_TYPE_DIO_BIT:
266                 if ((channel >= 0) && (channel < 8)) {
267                         mode =
268                             inb(instance->
269                                 ctrl_reg) & ((ME0600_DIO_CONFIG_BIT_OUT_0) <<
270                                              (instance->dio_idx * 2));
271
272                         if (mode ==
273                             (ME0600_DIO_CONFIG_BIT_OUT_0 <<
274                              (instance->dio_idx * 2))) {
275                                 byte = inb(instance->port_reg);
276
277                                 if (value)
278                                         byte |= 0x1 << channel;
279                                 else
280                                         byte &= ~(0x1 << channel);
281
282                                 outb(byte, instance->port_reg);
283                         } else {
284                                 PERROR("Port not in output or input mode.\n");
285                                 err = ME_ERRNO_PREVIOUS_CONFIG;
286                         }
287                 } else {
288                         PERROR("Invalid bit number specified.\n");
289                         err = ME_ERRNO_INVALID_CHANNEL;
290                 }
291
292                 break;
293
294         case ME_IO_SINGLE_NO_FLAGS:
295         case ME_IO_SINGLE_TYPE_DIO_BYTE:
296                 if (channel == 0) {
297                         mode =
298                             inb(instance->
299                                 ctrl_reg) & ((ME0600_DIO_CONFIG_BIT_OUT_0) <<
300                                              (instance->dio_idx * 2));
301
302                         if (mode ==
303                             (ME0600_DIO_CONFIG_BIT_OUT_0 <<
304                              (instance->dio_idx * 2))) {
305                                 outb(value, instance->port_reg);
306                         } else {
307                                 PERROR("Port not in output or input mode.\n");
308                                 err = ME_ERRNO_PREVIOUS_CONFIG;
309                         }
310                 } else {
311                         PERROR("Invalid byte number specified.\n");
312                         err = ME_ERRNO_INVALID_CHANNEL;
313                 }
314
315                 break;
316
317         default:
318                 PERROR("Invalid flags specified.\n");
319
320                 err = ME_ERRNO_INVALID_FLAGS;
321
322                 break;
323         }
324         spin_unlock(instance->ctrl_reg_lock);
325         spin_unlock(&instance->subdevice_lock);
326
327         ME_SUBDEVICE_EXIT;
328
329         return err;
330 }
331
332 static int me0600_dio_query_number_channels(me_subdevice_t *subdevice,
333                                             int *number)
334 {
335         PDEBUG("executed.\n");
336         *number = 8;
337         return ME_ERRNO_SUCCESS;
338 }
339
340 static int me0600_dio_query_subdevice_type(me_subdevice_t *subdevice,
341                                            int *type, int *subtype)
342 {
343         PDEBUG("executed.\n");
344         *type = ME_TYPE_DIO;
345         *subtype = ME_SUBTYPE_SINGLE;
346         return ME_ERRNO_SUCCESS;
347 }
348
349 static int me0600_dio_query_subdevice_caps(me_subdevice_t *subdevice,
350                                            int *caps)
351 {
352         PDEBUG("executed.\n");
353         *caps = ME_CAPS_DIO_DIR_BYTE;
354         return ME_ERRNO_SUCCESS;
355 }
356
357 me0600_dio_subdevice_t *me0600_dio_constructor(uint32_t reg_base,
358                                                unsigned int dio_idx,
359                                                spinlock_t *ctrl_reg_lock)
360 {
361         me0600_dio_subdevice_t *subdevice;
362         int err;
363
364         PDEBUG("executed.\n");
365
366         /* Allocate memory for subdevice instance */
367         subdevice = kmalloc(sizeof(me0600_dio_subdevice_t), GFP_KERNEL);
368
369         if (!subdevice) {
370                 PERROR("Cannot get memory for subdevice instance.\n");
371                 return NULL;
372         }
373
374         memset(subdevice, 0, sizeof(me0600_dio_subdevice_t));
375
376         /* Initialize subdevice base class */
377         err = me_subdevice_init(&subdevice->base);
378
379         if (err) {
380                 PERROR("Cannot initialize subdevice base class instance.\n");
381                 kfree(subdevice);
382                 return NULL;
383         }
384         /* Initialize spin locks. */
385         spin_lock_init(&subdevice->subdevice_lock);
386
387         subdevice->ctrl_reg_lock = ctrl_reg_lock;
388
389         /* Save digital i/o index */
390         subdevice->dio_idx = dio_idx;
391
392         /* Save the subdevice index */
393         subdevice->ctrl_reg = reg_base + ME0600_DIO_CONFIG_REG;
394         subdevice->port_reg = reg_base + ME0600_DIO_PORT_REG + dio_idx;
395 #ifdef MEDEBUG_DEBUG_REG
396         subdevice->reg_base = reg_base;
397 #endif
398
399         /* Overload base class methods. */
400         subdevice->base.me_subdevice_io_reset_subdevice =
401             me0600_dio_io_reset_subdevice;
402         subdevice->base.me_subdevice_io_single_config =
403             me0600_dio_io_single_config;
404         subdevice->base.me_subdevice_io_single_read = me0600_dio_io_single_read;
405         subdevice->base.me_subdevice_io_single_write =
406             me0600_dio_io_single_write;
407         subdevice->base.me_subdevice_query_number_channels =
408             me0600_dio_query_number_channels;
409         subdevice->base.me_subdevice_query_subdevice_type =
410             me0600_dio_query_subdevice_type;
411         subdevice->base.me_subdevice_query_subdevice_caps =
412             me0600_dio_query_subdevice_caps;
413
414         return subdevice;
415 }