pc2_gpib.c

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