1 // SPDX-License-Identifier: GPL-2.0
2
3 /***************************************************************************
4 * copyright : (C) 2001, 2002 by Frank Mori Hess
5 ***************************************************************************/
6
7 #include <linux/ioport.h>
8 #include <linux/sched.h>
9 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/bitops.h>
12 #include <asm/dma.h>
13 #include <linux/dma-mapping.h>
14 #include <linux/string.h>
15 #include <linux/init.h>
16 #include "nec7210.h"
17 #include "gpibP.h"
18
19 // struct which defines private_data for pc2 driver
20 struct pc2_priv {
21 struct nec7210_priv nec7210_priv;
22 unsigned int irq;
23 // io address that clears interrupt for pc2a (0x2f0 + irq)
24 unsigned int clear_intr_addr;
25 };
26
27 // pc2 uses 8 consecutive io addresses
28 static const int pc2_iosize = 8;
29 static const int pc2a_iosize = 8;
30 static const int pc2_2a_iosize = 16;
31
32 // offset between io addresses of successive nec7210 registers
33 static const int pc2a_reg_offset = 0x400;
34 static const int pc2_reg_offset = 1;
35
36 //interrupt service routine
37 static irqreturn_t pc2_interrupt(int irq, void *arg);
38 static irqreturn_t pc2a_interrupt(int irq, void *arg);
39
40 // pc2 specific registers and bits
41
42 // interrupt clear register address
43 static const int pc2a_clear_intr_iobase = 0x2f0;
CLEAR_INTR_REG(unsigned int irq)44 static inline unsigned int CLEAR_INTR_REG(unsigned int irq)
45 {
46 return pc2a_clear_intr_iobase + irq;
47 }
48
49 MODULE_LICENSE("GPL");
50 MODULE_DESCRIPTION("GPIB driver for PC2/PC2a and compatible devices");
51
52 static int pc2_attach(gpib_board_t *board, const gpib_board_config_t *config);
53 static int pc2a_attach(gpib_board_t *board, const gpib_board_config_t *config);
54 static int pc2a_cb7210_attach(gpib_board_t *board, const gpib_board_config_t *config);
55 static int pc2_2a_attach(gpib_board_t *board, const gpib_board_config_t *config);
56
57 static void pc2_detach(gpib_board_t *board);
58 static void pc2a_detach(gpib_board_t *board);
59 static void pc2_2a_detach(gpib_board_t *board);
60
61 /*
62 * GPIB interrupt service routines
63 */
64
pc2_interrupt(int irq,void * arg)65 irqreturn_t pc2_interrupt(int irq, void *arg)
66 {
67 gpib_board_t *board = arg;
68 struct pc2_priv *priv = board->private_data;
69 unsigned long flags;
70 irqreturn_t retval;
71
72 spin_lock_irqsave(&board->spinlock, flags);
73 retval = nec7210_interrupt(board, &priv->nec7210_priv);
74 spin_unlock_irqrestore(&board->spinlock, flags);
75 return retval;
76 }
77
pc2a_interrupt(int irq,void * arg)78 irqreturn_t pc2a_interrupt(int irq, void *arg)
79 {
80 gpib_board_t *board = arg;
81 struct pc2_priv *priv = board->private_data;
82 int status1, status2;
83 unsigned long flags;
84 irqreturn_t retval;
85
86 spin_lock_irqsave(&board->spinlock, flags);
87 // read interrupt status (also clears status)
88 status1 = read_byte(&priv->nec7210_priv, ISR1);
89 status2 = read_byte(&priv->nec7210_priv, ISR2);
90 /* clear interrupt circuit */
91 if (priv->irq)
92 outb(0xff, CLEAR_INTR_REG(priv->irq));
93 retval = nec7210_interrupt_have_status(board, &priv->nec7210_priv, status1, status2);
94 spin_unlock_irqrestore(&board->spinlock, flags);
95 return retval;
96 }
97
98 // wrappers for interface functions
pc2_read(gpib_board_t * board,uint8_t * buffer,size_t length,int * end,size_t * bytes_read)99 static int pc2_read(gpib_board_t *board, uint8_t *buffer, size_t length, int *end,
100 size_t *bytes_read)
101 {
102 struct pc2_priv *priv = board->private_data;
103
104 return nec7210_read(board, &priv->nec7210_priv, buffer, length, end, bytes_read);
105 }
106
pc2_write(gpib_board_t * board,uint8_t * buffer,size_t length,int send_eoi,size_t * bytes_written)107 static int pc2_write(gpib_board_t *board, uint8_t *buffer, size_t length, int send_eoi,
108 size_t *bytes_written)
109 {
110 struct pc2_priv *priv = board->private_data;
111
112 return nec7210_write(board, &priv->nec7210_priv, buffer, length, send_eoi, bytes_written);
113 }
114
pc2_command(gpib_board_t * board,uint8_t * buffer,size_t length,size_t * bytes_written)115 static int pc2_command(gpib_board_t *board, uint8_t *buffer, size_t length, size_t *bytes_written)
116 {
117 struct pc2_priv *priv = board->private_data;
118
119 return nec7210_command(board, &priv->nec7210_priv, buffer, length, bytes_written);
120 }
121
pc2_take_control(gpib_board_t * board,int synchronous)122 static int pc2_take_control(gpib_board_t *board, int synchronous)
123 {
124 struct pc2_priv *priv = board->private_data;
125
126 return nec7210_take_control(board, &priv->nec7210_priv, synchronous);
127 }
128
pc2_go_to_standby(gpib_board_t * board)129 static int pc2_go_to_standby(gpib_board_t *board)
130 {
131 struct pc2_priv *priv = board->private_data;
132
133 return nec7210_go_to_standby(board, &priv->nec7210_priv);
134 }
135
pc2_request_system_control(gpib_board_t * board,int request_control)136 static void pc2_request_system_control(gpib_board_t *board, int request_control)
137 {
138 struct pc2_priv *priv = board->private_data;
139
140 nec7210_request_system_control(board, &priv->nec7210_priv, request_control);
141 }
142
pc2_interface_clear(gpib_board_t * board,int assert)143 static void pc2_interface_clear(gpib_board_t *board, int assert)
144 {
145 struct pc2_priv *priv = board->private_data;
146
147 nec7210_interface_clear(board, &priv->nec7210_priv, assert);
148 }
149
pc2_remote_enable(gpib_board_t * board,int enable)150 static void pc2_remote_enable(gpib_board_t *board, int enable)
151 {
152 struct pc2_priv *priv = board->private_data;
153
154 nec7210_remote_enable(board, &priv->nec7210_priv, enable);
155 }
156
pc2_enable_eos(gpib_board_t * board,uint8_t eos_byte,int compare_8_bits)157 static int pc2_enable_eos(gpib_board_t *board, uint8_t eos_byte, int compare_8_bits)
158 {
159 struct pc2_priv *priv = board->private_data;
160
161 return nec7210_enable_eos(board, &priv->nec7210_priv, eos_byte, compare_8_bits);
162 }
163
pc2_disable_eos(gpib_board_t * board)164 static void pc2_disable_eos(gpib_board_t *board)
165 {
166 struct pc2_priv *priv = board->private_data;
167
168 nec7210_disable_eos(board, &priv->nec7210_priv);
169 }
170
pc2_update_status(gpib_board_t * board,unsigned int clear_mask)171 static unsigned int pc2_update_status(gpib_board_t *board, unsigned int clear_mask)
172 {
173 struct pc2_priv *priv = board->private_data;
174
175 return nec7210_update_status(board, &priv->nec7210_priv, clear_mask);
176 }
177
pc2_primary_address(gpib_board_t * board,unsigned int address)178 static int pc2_primary_address(gpib_board_t *board, unsigned int address)
179 {
180 struct pc2_priv *priv = board->private_data;
181
182 return nec7210_primary_address(board, &priv->nec7210_priv, address);
183 }
184
pc2_secondary_address(gpib_board_t * board,unsigned int address,int enable)185 static int pc2_secondary_address(gpib_board_t *board, unsigned int address, int enable)
186 {
187 struct pc2_priv *priv = board->private_data;
188
189 return nec7210_secondary_address(board, &priv->nec7210_priv, address, enable);
190 }
191
pc2_parallel_poll(gpib_board_t * board,uint8_t * result)192 static int pc2_parallel_poll(gpib_board_t *board, uint8_t *result)
193 {
194 struct pc2_priv *priv = board->private_data;
195
196 return nec7210_parallel_poll(board, &priv->nec7210_priv, result);
197 }
198
pc2_parallel_poll_configure(gpib_board_t * board,uint8_t config)199 static void pc2_parallel_poll_configure(gpib_board_t *board, uint8_t config)
200 {
201 struct pc2_priv *priv = board->private_data;
202
203 nec7210_parallel_poll_configure(board, &priv->nec7210_priv, config);
204 }
205
pc2_parallel_poll_response(gpib_board_t * board,int ist)206 static void pc2_parallel_poll_response(gpib_board_t *board, int ist)
207 {
208 struct pc2_priv *priv = board->private_data;
209
210 nec7210_parallel_poll_response(board, &priv->nec7210_priv, ist);
211 }
212
pc2_serial_poll_response(gpib_board_t * board,uint8_t status)213 static void pc2_serial_poll_response(gpib_board_t *board, uint8_t status)
214 {
215 struct pc2_priv *priv = board->private_data;
216
217 nec7210_serial_poll_response(board, &priv->nec7210_priv, status);
218 }
219
pc2_serial_poll_status(gpib_board_t * board)220 static uint8_t pc2_serial_poll_status(gpib_board_t *board)
221 {
222 struct pc2_priv *priv = board->private_data;
223
224 return nec7210_serial_poll_status(board, &priv->nec7210_priv);
225 }
226
pc2_t1_delay(gpib_board_t * board,unsigned int nano_sec)227 static unsigned int pc2_t1_delay(gpib_board_t *board, unsigned int nano_sec)
228 {
229 struct pc2_priv *priv = board->private_data;
230
231 return nec7210_t1_delay(board, &priv->nec7210_priv, nano_sec);
232 }
233
pc2_return_to_local(gpib_board_t * board)234 static void pc2_return_to_local(gpib_board_t *board)
235 {
236 struct pc2_priv *priv = board->private_data;
237
238 nec7210_return_to_local(board, &priv->nec7210_priv);
239 }
240
241 static gpib_interface_t pc2_interface = {
242 .name = "pcII",
243 .attach = pc2_attach,
244 .detach = pc2_detach,
245 .read = pc2_read,
246 .write = pc2_write,
247 .command = pc2_command,
248 .take_control = pc2_take_control,
249 .go_to_standby = pc2_go_to_standby,
250 .request_system_control = pc2_request_system_control,
251 .interface_clear = pc2_interface_clear,
252 .remote_enable = pc2_remote_enable,
253 .enable_eos = pc2_enable_eos,
254 .disable_eos = pc2_disable_eos,
255 .parallel_poll = pc2_parallel_poll,
256 .parallel_poll_configure = pc2_parallel_poll_configure,
257 .parallel_poll_response = pc2_parallel_poll_response,
258 .local_parallel_poll_mode = NULL, // XXX
259 .line_status = NULL,
260 .update_status = pc2_update_status,
261 .primary_address = pc2_primary_address,
262 .secondary_address = pc2_secondary_address,
263 .serial_poll_response = pc2_serial_poll_response,
264 .serial_poll_status = pc2_serial_poll_status,
265 .t1_delay = pc2_t1_delay,
266 .return_to_local = pc2_return_to_local,
267 };
268
269 static gpib_interface_t pc2a_interface = {
270 .name = "pcIIa",
271 .attach = pc2a_attach,
272 .detach = pc2a_detach,
273 .read = pc2_read,
274 .write = pc2_write,
275 .command = pc2_command,
276 .take_control = pc2_take_control,
277 .go_to_standby = pc2_go_to_standby,
278 .request_system_control = pc2_request_system_control,
279 .interface_clear = pc2_interface_clear,
280 .remote_enable = pc2_remote_enable,
281 .enable_eos = pc2_enable_eos,
282 .disable_eos = pc2_disable_eos,
283 .parallel_poll = pc2_parallel_poll,
284 .parallel_poll_configure = pc2_parallel_poll_configure,
285 .parallel_poll_response = pc2_parallel_poll_response,
286 .local_parallel_poll_mode = NULL, // XXX
287 .line_status = NULL,
288 .update_status = pc2_update_status,
289 .primary_address = pc2_primary_address,
290 .secondary_address = pc2_secondary_address,
291 .serial_poll_response = pc2_serial_poll_response,
292 .serial_poll_status = pc2_serial_poll_status,
293 .t1_delay = pc2_t1_delay,
294 .return_to_local = pc2_return_to_local,
295 };
296
297 static gpib_interface_t pc2a_cb7210_interface = {
298 .name = "pcIIa_cb7210",
299 .attach = pc2a_cb7210_attach,
300 .detach = pc2a_detach,
301 .read = pc2_read,
302 .write = pc2_write,
303 .command = pc2_command,
304 .take_control = pc2_take_control,
305 .go_to_standby = pc2_go_to_standby,
306 .request_system_control = pc2_request_system_control,
307 .interface_clear = pc2_interface_clear,
308 .remote_enable = pc2_remote_enable,
309 .enable_eos = pc2_enable_eos,
310 .disable_eos = pc2_disable_eos,
311 .parallel_poll = pc2_parallel_poll,
312 .parallel_poll_configure = pc2_parallel_poll_configure,
313 .parallel_poll_response = pc2_parallel_poll_response,
314 .local_parallel_poll_mode = NULL, // XXX
315 .line_status = NULL, //XXX
316 .update_status = pc2_update_status,
317 .primary_address = pc2_primary_address,
318 .secondary_address = pc2_secondary_address,
319 .serial_poll_response = pc2_serial_poll_response,
320 .serial_poll_status = pc2_serial_poll_status,
321 .t1_delay = pc2_t1_delay,
322 .return_to_local = pc2_return_to_local,
323 };
324
325 static gpib_interface_t pc2_2a_interface = {
326 .name = "pcII_IIa",
327 .attach = pc2_2a_attach,
328 .detach = pc2_2a_detach,
329 .read = pc2_read,
330 .write = pc2_write,
331 .command = pc2_command,
332 .take_control = pc2_take_control,
333 .go_to_standby = pc2_go_to_standby,
334 .request_system_control = pc2_request_system_control,
335 .interface_clear = pc2_interface_clear,
336 .remote_enable = pc2_remote_enable,
337 .enable_eos = pc2_enable_eos,
338 .disable_eos = pc2_disable_eos,
339 .parallel_poll = pc2_parallel_poll,
340 .parallel_poll_configure = pc2_parallel_poll_configure,
341 .parallel_poll_response = pc2_parallel_poll_response,
342 .local_parallel_poll_mode = NULL, // XXX
343 .line_status = NULL,
344 .update_status = pc2_update_status,
345 .primary_address = pc2_primary_address,
346 .secondary_address = pc2_secondary_address,
347 .serial_poll_response = pc2_serial_poll_response,
348 .serial_poll_status = pc2_serial_poll_status,
349 .t1_delay = pc2_t1_delay,
350 .return_to_local = pc2_return_to_local,
351 };
352
allocate_private(gpib_board_t * board)353 static int allocate_private(gpib_board_t *board)
354 {
355 struct pc2_priv *priv;
356
357 board->private_data = kmalloc(sizeof(struct pc2_priv), GFP_KERNEL);
358 if (!board->private_data)
359 return -1;
360 priv = board->private_data;
361 memset(priv, 0, sizeof(struct pc2_priv));
362 init_nec7210_private(&priv->nec7210_priv);
363 return 0;
364 }
365
free_private(gpib_board_t * board)366 static void free_private(gpib_board_t *board)
367 {
368 kfree(board->private_data);
369 board->private_data = NULL;
370 }
371
pc2_generic_attach(gpib_board_t * board,const gpib_board_config_t * config,enum nec7210_chipset chipset)372 static int pc2_generic_attach(gpib_board_t *board, const gpib_board_config_t *config,
373 enum nec7210_chipset chipset)
374 {
375 struct pc2_priv *pc2_priv;
376 struct nec7210_priv *nec_priv;
377
378 board->status = 0;
379 if (allocate_private(board))
380 return -ENOMEM;
381 pc2_priv = board->private_data;
382 nec_priv = &pc2_priv->nec7210_priv;
383 nec_priv->read_byte = nec7210_ioport_read_byte;
384 nec_priv->write_byte = nec7210_ioport_write_byte;
385 nec_priv->type = chipset;
386
387 #ifndef PC2_DMA
388 /* board->dev hasn't been initialized, so forget about DMA until this driver
389 * is adapted to use isa_register_driver.
390 */
391 if (config->ibdma)
392 pr_err("DMA disabled for pc2 gpib, driver needs to be adapted to use isa_register_driver to get a struct device*");
393 #else
394 if (config->ibdma) {
395 nec_priv->dma_buffer_length = 0x1000;
396 nec_priv->dma_buffer = dma_alloc_coherent(board->dev,
397 nec_priv->dma_buffer_length, &
398 nec_priv->dma_buffer_addr, GFP_ATOMIC);
399 if (!nec_priv->dma_buffer)
400 return -ENOMEM;
401
402 // request isa dma channel
403 if (request_dma(config->ibdma, "pc2")) {
404 pr_err("gpib: can't request DMA %d\n", config->ibdma);
405 return -1;
406 }
407 nec_priv->dma_channel = config->ibdma;
408 }
409 #endif
410
411 return 0;
412 }
413
pc2_attach(gpib_board_t * board,const gpib_board_config_t * config)414 int pc2_attach(gpib_board_t *board, const gpib_board_config_t *config)
415 {
416 int isr_flags = 0;
417 struct pc2_priv *pc2_priv;
418 struct nec7210_priv *nec_priv;
419 int retval;
420
421 retval = pc2_generic_attach(board, config, NEC7210);
422 if (retval)
423 return retval;
424
425 pc2_priv = board->private_data;
426 nec_priv = &pc2_priv->nec7210_priv;
427 nec_priv->offset = pc2_reg_offset;
428
429 if (!request_region(config->ibbase, pc2_iosize, "pc2")) {
430 pr_err("gpib: ioports are already in use\n");
431 return -1;
432 }
433 nec_priv->iobase = config->ibbase;
434
435 nec7210_board_reset(nec_priv, board);
436
437 // install interrupt handler
438 if (config->ibirq) {
439 if (request_irq(config->ibirq, pc2_interrupt, isr_flags, "pc2", board)) {
440 pr_err("gpib: can't request IRQ %d\n", config->ibirq);
441 return -1;
442 }
443 }
444 pc2_priv->irq = config->ibirq;
445 /* poll so we can detect assertion of ATN */
446 if (gpib_request_pseudo_irq(board, pc2_interrupt)) {
447 pr_err("pc2_gpib: failed to allocate pseudo_irq\n");
448 return -1;
449 }
450 /* set internal counter register for 8 MHz input clock */
451 write_byte(nec_priv, ICR | 8, AUXMR);
452
453 nec7210_board_online(nec_priv, board);
454
455 return 0;
456 }
457
pc2_detach(gpib_board_t * board)458 void pc2_detach(gpib_board_t *board)
459 {
460 struct pc2_priv *pc2_priv = board->private_data;
461 struct nec7210_priv *nec_priv;
462
463 if (pc2_priv) {
464 nec_priv = &pc2_priv->nec7210_priv;
465 #ifdef PC2_DMA
466 if (nec_priv->dma_channel)
467 free_dma(nec_priv->dma_channel);
468 #endif
469 gpib_free_pseudo_irq(board);
470 if (pc2_priv->irq)
471 free_irq(pc2_priv->irq, board);
472 if (nec_priv->iobase) {
473 nec7210_board_reset(nec_priv, board);
474 release_region(nec_priv->iobase, pc2_iosize);
475 }
476 if (nec_priv->dma_buffer) {
477 dma_free_coherent(board->dev, nec_priv->dma_buffer_length,
478 nec_priv->dma_buffer, nec_priv->dma_buffer_addr);
479 nec_priv->dma_buffer = NULL;
480 }
481 }
482 free_private(board);
483 }
484
pc2a_common_attach(gpib_board_t * board,const gpib_board_config_t * config,unsigned int num_registers,enum nec7210_chipset chipset)485 static int pc2a_common_attach(gpib_board_t *board, const gpib_board_config_t *config,
486 unsigned int num_registers, enum nec7210_chipset chipset)
487 {
488 unsigned int i, j;
489 struct pc2_priv *pc2_priv;
490 struct nec7210_priv *nec_priv;
491 int retval;
492
493 retval = pc2_generic_attach(board, config, chipset);
494 if (retval)
495 return retval;
496
497 pc2_priv = board->private_data;
498 nec_priv = &pc2_priv->nec7210_priv;
499 nec_priv->offset = pc2a_reg_offset;
500
501 switch (config->ibbase) {
502 case 0x02e1:
503 case 0x22e1:
504 case 0x42e1:
505 case 0x62e1:
506 break;
507 default:
508 pr_err("PCIIa base range invalid, must be one of 0x[0246]2e1, but is 0x%d\n",
509 config->ibbase);
510 return -1;
511 }
512
513 if (config->ibirq) {
514 if (config->ibirq < 2 || config->ibirq > 7) {
515 pr_err("pc2_gpib: illegal interrupt level %i\n", config->ibirq);
516 return -1;
517 }
518 } else {
519 pr_err("pc2_gpib: interrupt disabled, using polling mode (slow)\n");
520 }
521 #ifdef CHECK_IOPORTS
522 unsigned int err = 0;
523
524 for (i = 0; i < num_registers; i++) {
525 if (check_region(config->ibbase + i * pc2a_reg_offset, 1))
526 err++;
527 }
528 if (config->ibirq && check_region(pc2a_clear_intr_iobase + config->ibirq, 1))
529 err++;
530 if (err) {
531 pr_err("gpib: ioports are already in use");
532 return -1;
533 }
534 #endif
535 for (i = 0; i < num_registers; i++) {
536 if (!request_region(config->ibbase +
537 i * pc2a_reg_offset, 1, "pc2a")) {
538 pr_err("gpib: ioports are already in use");
539 for (j = 0; j < i; j++)
540 release_region(config->ibbase +
541 j * pc2a_reg_offset, 1);
542 return -1;
543 }
544 }
545 nec_priv->iobase = config->ibbase;
546 if (config->ibirq) {
547 if (!request_region(pc2a_clear_intr_iobase + config->ibirq, 1, "pc2a")) {
548 pr_err("gpib: ioports are already in use");
549 return -1;
550 }
551 pc2_priv->clear_intr_addr = pc2a_clear_intr_iobase + config->ibirq;
552 if (request_irq(config->ibirq, pc2a_interrupt, 0, "pc2a", board)) {
553 pr_err("gpib: can't request IRQ %d\n", config->ibirq);
554 return -1;
555 }
556 }
557 pc2_priv->irq = config->ibirq;
558 /* poll so we can detect assertion of ATN */
559 if (gpib_request_pseudo_irq(board, pc2_interrupt)) {
560 pr_err("pc2_gpib: failed to allocate pseudo_irq\n");
561 return -1;
562 }
563
564 // make sure interrupt is clear
565 if (pc2_priv->irq)
566 outb(0xff, CLEAR_INTR_REG(pc2_priv->irq));
567
568 nec7210_board_reset(nec_priv, board);
569
570 /* set internal counter register for 8 MHz input clock */
571 write_byte(nec_priv, ICR | 8, AUXMR);
572
573 nec7210_board_online(nec_priv, board);
574
575 return 0;
576 }
577
pc2a_attach(gpib_board_t * board,const gpib_board_config_t * config)578 int pc2a_attach(gpib_board_t *board, const gpib_board_config_t *config)
579 {
580 return pc2a_common_attach(board, config, pc2a_iosize, NEC7210);
581 }
582
pc2a_cb7210_attach(gpib_board_t * board,const gpib_board_config_t * config)583 int pc2a_cb7210_attach(gpib_board_t *board, const gpib_board_config_t *config)
584 {
585 return pc2a_common_attach(board, config, pc2a_iosize, CB7210);
586 }
587
pc2_2a_attach(gpib_board_t * board,const gpib_board_config_t * config)588 int pc2_2a_attach(gpib_board_t *board, const gpib_board_config_t *config)
589 {
590 return pc2a_common_attach(board, config, pc2_2a_iosize, NAT4882);
591 }
592
pc2a_common_detach(gpib_board_t * board,unsigned int num_registers)593 static void pc2a_common_detach(gpib_board_t *board, unsigned int num_registers)
594 {
595 int i;
596 struct pc2_priv *pc2_priv = board->private_data;
597 struct nec7210_priv *nec_priv;
598
599 if (pc2_priv) {
600 nec_priv = &pc2_priv->nec7210_priv;
601 #ifdef PC2_DMA
602 if (nec_priv->dma_channel)
603 free_dma(nec_priv->dma_channel);
604 #endif
605 gpib_free_pseudo_irq(board);
606 if (pc2_priv->irq)
607 free_irq(pc2_priv->irq, board);
608 if (nec_priv->iobase) {
609 nec7210_board_reset(nec_priv, board);
610 for (i = 0; i < num_registers; i++)
611 release_region(nec_priv->iobase +
612 i * pc2a_reg_offset, 1);
613 }
614 if (pc2_priv->clear_intr_addr)
615 release_region(pc2_priv->clear_intr_addr, 1);
616 if (nec_priv->dma_buffer) {
617 dma_free_coherent(board->dev, nec_priv->dma_buffer_length,
618 nec_priv->dma_buffer,
619 nec_priv->dma_buffer_addr);
620 nec_priv->dma_buffer = NULL;
621 }
622 }
623 free_private(board);
624 }
625
pc2a_detach(gpib_board_t * board)626 void pc2a_detach(gpib_board_t *board)
627 {
628 pc2a_common_detach(board, pc2a_iosize);
629 }
630
pc2_2a_detach(gpib_board_t * board)631 void pc2_2a_detach(gpib_board_t *board)
632 {
633 pc2a_common_detach(board, pc2_2a_iosize);
634 }
635
pc2_init_module(void)636 static int __init pc2_init_module(void)
637 {
638 int ret;
639
640 ret = gpib_register_driver(&pc2_interface, THIS_MODULE);
641 if (ret) {
642 pr_err("pc2_gpib: gpib_register_driver failed: error = %d\n", ret);
643 return ret;
644 }
645
646 ret = gpib_register_driver(&pc2a_interface, THIS_MODULE);
647 if (ret) {
648 pr_err("pc2_gpib: gpib_register_driver failed: error = %d\n", ret);
649 goto err_pc2a;
650 }
651
652 ret = gpib_register_driver(&pc2a_cb7210_interface, THIS_MODULE);
653 if (ret) {
654 pr_err("pc2_gpib: gpib_register_driver failed: error = %d\n", ret);
655 goto err_cb7210;
656 }
657
658 ret = gpib_register_driver(&pc2_2a_interface, THIS_MODULE);
659 if (ret) {
660 pr_err("pc2_gpib: gpib_register_driver failed: error = %d\n", ret);
661 goto err_pc2_2a;
662 }
663
664 return 0;
665
666 err_pc2_2a:
667 gpib_unregister_driver(&pc2a_cb7210_interface);
668 err_cb7210:
669 gpib_unregister_driver(&pc2a_interface);
670 err_pc2a:
671 gpib_unregister_driver(&pc2_interface);
672
673 return ret;
674 }
675
pc2_exit_module(void)676 static void __exit pc2_exit_module(void)
677 {
678 gpib_unregister_driver(&pc2_interface);
679 gpib_unregister_driver(&pc2a_interface);
680 gpib_unregister_driver(&pc2a_cb7210_interface);
681 gpib_unregister_driver(&pc2_2a_interface);
682 }
683
684 module_init(pc2_init_module);
685 module_exit(pc2_exit_module);
686
687