Merge branch 'audit.b62' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/audit...
[linux-2.6] / drivers / staging / meilhaus / me6000_dio.c
1 /**
2  * @file me6000_dio.c
3  *
4  * @brief ME-6000 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 "me6000_dio_reg.h"
48 #include "me6000_dio.h"
49
50 /*
51  * Defines
52  */
53
54 /*
55  * Functions
56  */
57
58 static int me6000_dio_io_reset_subdevice(struct me_subdevice *subdevice,
59                                          struct file *filep, int flags)
60 {
61         me6000_dio_subdevice_t *instance;
62         uint8_t mode;
63
64         PDEBUG("executed.\n");
65
66         instance = (me6000_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("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
86                    instance->ctrl_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 me6000_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         me6000_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 = (me6000_dio_subdevice_t *) subdevice;
113
114         ME_SUBDEVICE_ENTER spin_lock(&instance->subdevice_lock);
115         spin_lock(instance->ctrl_reg_lock);
116         mode = inb(instance->ctrl_reg);
117         switch (size) {
118         case ME_IO_SINGLE_CONFIG_NO_FLAGS:
119         case ME_IO_SINGLE_CONFIG_DIO_BYTE:
120                 if (channel == 0) {
121                         if (single_config == ME_SINGLE_CONFIG_DIO_INPUT) {
122                                 mode &=
123                                     ~((ME6000_DIO_CTRL_BIT_MODE_0 |
124                                        ME6000_DIO_CTRL_BIT_MODE_1) <<
125                                       (instance->dio_idx * 2));
126                         } else if (single_config == ME_SINGLE_CONFIG_DIO_OUTPUT) {
127                                 mode &=
128                                     ~((ME6000_DIO_CTRL_BIT_MODE_0 |
129                                        ME6000_DIO_CTRL_BIT_MODE_1) <<
130                                       (instance->dio_idx * 2));
131                                 mode |=
132                                     ME6000_DIO_CTRL_BIT_MODE_0 << (instance->
133                                                                    dio_idx * 2);
134                         } else {
135                                 PERROR
136                                     ("Invalid port configuration specified.\n");
137                                 err = ME_ERRNO_INVALID_SINGLE_CONFIG;
138                         }
139                 } else {
140                         PERROR("Invalid channel number.\n");
141                         err = ME_ERRNO_INVALID_CHANNEL;
142                 }
143                 break;
144
145         default:
146                 PERROR("Invalid flags.\n");
147                 err = ME_ERRNO_INVALID_FLAGS;
148         }
149
150         if (!err) {
151                 outb(mode, instance->ctrl_reg);
152                 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
153                            instance->reg_base,
154                            instance->ctrl_reg - instance->reg_base, mode);
155         }
156         spin_unlock(instance->ctrl_reg_lock);
157         spin_unlock(&instance->subdevice_lock);
158
159         ME_SUBDEVICE_EXIT;
160
161         return err;
162 }
163
164 static int me6000_dio_io_single_read(me_subdevice_t *subdevice,
165                                      struct file *filep,
166                                      int channel,
167                                      int *value, int time_out, int flags)
168 {
169         me6000_dio_subdevice_t *instance;
170         int err = ME_ERRNO_SUCCESS;
171         uint8_t mode;
172
173         PDEBUG("executed.\n");
174
175         instance = (me6000_dio_subdevice_t *) subdevice;
176
177         ME_SUBDEVICE_ENTER spin_lock(&instance->subdevice_lock);
178         spin_lock(instance->ctrl_reg_lock);
179         switch (flags) {
180         case ME_IO_SINGLE_TYPE_DIO_BIT:
181                 if ((channel >= 0) && (channel < 8)) {
182                         mode =
183                             inb(instance->
184                                 ctrl_reg) & ((ME6000_DIO_CTRL_BIT_MODE_0 |
185                                               ME6000_DIO_CTRL_BIT_MODE_1) <<
186                                              (instance->dio_idx * 2));
187                         if ((mode ==
188                              (ME6000_DIO_CTRL_BIT_MODE_0 <<
189                               (instance->dio_idx * 2))) || !mode) {
190                                 *value =
191                                     inb(instance->port_reg) & (0x1 << channel);
192                         } else {
193                                 PERROR("Port not in output or input mode.\n");
194                                 err = ME_ERRNO_PREVIOUS_CONFIG;
195                         }
196                 } else {
197                         PERROR("Invalid bit number specified.\n");
198                         err = ME_ERRNO_INVALID_CHANNEL;
199                 }
200                 break;
201
202         case ME_IO_SINGLE_NO_FLAGS:
203         case ME_IO_SINGLE_TYPE_DIO_BYTE:
204                 if (channel == 0) {
205                         mode =
206                             inb(instance->
207                                 ctrl_reg) & ((ME6000_DIO_CTRL_BIT_MODE_0 |
208                                               ME6000_DIO_CTRL_BIT_MODE_1) <<
209                                              (instance->dio_idx * 2));
210                         if ((mode ==
211                              (ME6000_DIO_CTRL_BIT_MODE_0 <<
212                               (instance->dio_idx * 2))) || !mode) {
213                                 *value = inb(instance->port_reg) & 0x00FF;
214                         } else {
215                                 PERROR("Port not in output or input mode.\n");
216                                 err = ME_ERRNO_PREVIOUS_CONFIG;
217                         }
218                 } else {
219                         PERROR("Invalid byte number specified.\n");
220                         err = ME_ERRNO_INVALID_CHANNEL;
221                 }
222                 break;
223
224         default:
225                 PERROR("Invalid flags specified.\n");
226                 err = ME_ERRNO_INVALID_FLAGS;
227         }
228         spin_unlock(instance->ctrl_reg_lock);
229         spin_unlock(&instance->subdevice_lock);
230
231         ME_SUBDEVICE_EXIT;
232
233         return err;
234 }
235
236 static int me6000_dio_io_single_write(me_subdevice_t *subdevice,
237                                       struct file *filep,
238                                       int channel,
239                                       int value, int time_out, int flags)
240 {
241         me6000_dio_subdevice_t *instance;
242         int err = ME_ERRNO_SUCCESS;
243         uint8_t mode;
244         uint8_t byte;
245
246         PDEBUG("executed.\n");
247
248         instance = (me6000_dio_subdevice_t *) subdevice;
249
250         ME_SUBDEVICE_ENTER spin_lock(&instance->subdevice_lock);
251         spin_lock(instance->ctrl_reg_lock);
252         switch (flags) {
253         case ME_IO_SINGLE_TYPE_DIO_BIT:
254                 if ((channel >= 0) && (channel < 8)) {
255                         mode =
256                             inb(instance->
257                                 ctrl_reg) & ((ME6000_DIO_CTRL_BIT_MODE_0 |
258                                               ME6000_DIO_CTRL_BIT_MODE_1) <<
259                                              (instance->dio_idx * 2));
260
261                         if (mode ==
262                             (ME6000_DIO_CTRL_BIT_MODE_0 <<
263                              (instance->dio_idx * 2))) {
264                                 byte = inb(instance->port_reg) & 0x00FF;
265
266                                 if (value)
267                                         byte |= 0x1 << channel;
268                                 else
269                                         byte &= ~(0x1 << channel);
270
271                                 outb(byte, instance->port_reg);
272                         } else {
273                                 PERROR("Port not in output or input mode.\n");
274                                 err = ME_ERRNO_PREVIOUS_CONFIG;
275                         }
276                 } else {
277                         PERROR("Invalid bit number specified.\n");
278                         err = ME_ERRNO_INVALID_CHANNEL;
279                 }
280                 break;
281
282         case ME_IO_SINGLE_NO_FLAGS:
283         case ME_IO_SINGLE_TYPE_DIO_BYTE:
284                 if (channel == 0) {
285                         mode =
286                             inb(instance->
287                                 ctrl_reg) & ((ME6000_DIO_CTRL_BIT_MODE_0 |
288                                               ME6000_DIO_CTRL_BIT_MODE_1) <<
289                                              (instance->dio_idx * 2));
290
291                         if (mode ==
292                             (ME6000_DIO_CTRL_BIT_MODE_0 <<
293                              (instance->dio_idx * 2))) {
294                                 outb(value, instance->port_reg);
295                         } else {
296                                 PERROR("Port not in output or input mode.\n");
297                                 err = ME_ERRNO_PREVIOUS_CONFIG;
298                         }
299                 } else {
300                         PERROR("Invalid byte number specified.\n");
301                         err = ME_ERRNO_INVALID_CHANNEL;
302                 }
303                 break;
304
305         default:
306                 PERROR("Invalid flags specified.\n");
307                 err = ME_ERRNO_INVALID_FLAGS;
308         }
309         spin_unlock(instance->ctrl_reg_lock);
310         spin_unlock(&instance->subdevice_lock);
311
312         ME_SUBDEVICE_EXIT;
313
314         return err;
315 }
316
317 static int me6000_dio_query_number_channels(me_subdevice_t *subdevice,
318                                             int *number)
319 {
320         PDEBUG("executed.\n");
321         *number = 8;
322         return ME_ERRNO_SUCCESS;
323 }
324
325 static int me6000_dio_query_subdevice_type(me_subdevice_t *subdevice,
326                                            int *type, int *subtype)
327 {
328         PDEBUG("executed.\n");
329         *type = ME_TYPE_DIO;
330         *subtype = ME_SUBTYPE_SINGLE;
331         return ME_ERRNO_SUCCESS;
332 }
333
334 static int me6000_dio_query_subdevice_caps(me_subdevice_t *subdevice,
335                                            int *caps)
336 {
337         PDEBUG("executed.\n");
338         *caps = ME_CAPS_DIO_DIR_BYTE;
339         return ME_ERRNO_SUCCESS;
340 }
341
342 me6000_dio_subdevice_t *me6000_dio_constructor(uint32_t reg_base,
343                                                unsigned int dio_idx,
344                                                spinlock_t *ctrl_reg_lock)
345 {
346         me6000_dio_subdevice_t *subdevice;
347         int err;
348
349         PDEBUG("executed.\n");
350
351         /* Allocate memory for subdevice instance */
352         subdevice = kmalloc(sizeof(me6000_dio_subdevice_t), GFP_KERNEL);
353
354         if (!subdevice) {
355                 PERROR("Cannot get memory for subdevice instance.\n");
356                 return NULL;
357         }
358
359         memset(subdevice, 0, sizeof(me6000_dio_subdevice_t));
360
361         /* Initialize subdevice base class */
362         err = me_subdevice_init(&subdevice->base);
363         if (err) {
364                 PERROR("Cannot initialize subdevice base class instance.\n");
365                 kfree(subdevice);
366                 return NULL;
367         }
368
369         /* Set the subdevice ports */
370         subdevice->ctrl_reg = reg_base + ME6000_DIO_CTRL_REG;
371         switch (dio_idx) {
372         case 0:
373                 subdevice->port_reg = reg_base + ME6000_DIO_PORT_0_REG;
374                 break;
375         case 1:
376                 subdevice->port_reg = reg_base + ME6000_DIO_PORT_1_REG;
377                 break;
378         default:
379                 err = ME_ERRNO_INVALID_SUBDEVICE;
380         }
381
382         if (err) {
383                 PERROR("Cannot initialize subdevice base class instance.\n");
384                 kfree(subdevice);
385                 return NULL;
386         }
387         // Initialize spin locks.
388         spin_lock_init(&subdevice->subdevice_lock);
389
390         subdevice->ctrl_reg_lock = ctrl_reg_lock;
391
392         /* Save digital i/o index */
393         subdevice->dio_idx = dio_idx;
394
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             me6000_dio_io_reset_subdevice;
402         subdevice->base.me_subdevice_io_single_config =
403             me6000_dio_io_single_config;
404         subdevice->base.me_subdevice_io_single_read = me6000_dio_io_single_read;
405         subdevice->base.me_subdevice_io_single_write =
406             me6000_dio_io_single_write;
407         subdevice->base.me_subdevice_query_number_channels =
408             me6000_dio_query_number_channels;
409         subdevice->base.me_subdevice_query_subdevice_type =
410             me6000_dio_query_subdevice_type;
411         subdevice->base.me_subdevice_query_subdevice_caps =
412             me6000_dio_query_subdevice_caps;
413
414         return subdevice;
415 }