1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /*****************************************************************************/ |
3 | |
4 | /* |
5 | * baycom_par.c -- baycom par96 and picpar radio modem driver. |
6 | * |
7 | * Copyright (C) 1996-2000 Thomas Sailer (sailer@ife.ee.ethz.ch) |
8 | * |
9 | * Please note that the GPL allows you to use the driver, NOT the radio. |
10 | * In order to use the radio, you need a license from the communications |
11 | * authority of your country. |
12 | * |
13 | * Supported modems |
14 | * |
15 | * par96: This is a modem for 9600 baud FSK compatible to the G3RUH standard. |
16 | * The modem does all the filtering and regenerates the receiver clock. |
17 | * Data is transferred from and to the PC via a shift register. |
18 | * The shift register is filled with 16 bits and an interrupt is |
19 | * signalled. The PC then empties the shift register in a burst. This |
20 | * modem connects to the parallel port, hence the name. The modem |
21 | * leaves the implementation of the HDLC protocol and the scrambler |
22 | * polynomial to the PC. This modem is no longer available (at least |
23 | * from Baycom) and has been replaced by the PICPAR modem (see below). |
24 | * You may however still build one from the schematics published in |
25 | * cq-DL :-). |
26 | * |
27 | * picpar: This is a redesign of the par96 modem by Henning Rech, DF9IC. The |
28 | * modem is protocol compatible to par96, but uses only three low |
29 | * power ICs and can therefore be fed from the parallel port and |
30 | * does not require an additional power supply. It features |
31 | * built in DCD circuitry. The driver should therefore be configured |
32 | * for hardware DCD. |
33 | * |
34 | * Command line options (insmod command line) |
35 | * |
36 | * mode driver mode string. Valid choices are par96 and picpar. |
37 | * iobase base address of the port; common values are 0x378, 0x278, 0x3bc |
38 | * |
39 | * History: |
40 | * 0.1 26.06.1996 Adapted from baycom.c and made network driver interface |
41 | * 18.10.1996 Changed to new user space access routines (copy_{to,from}_user) |
42 | * 0.3 26.04.1997 init code/data tagged |
43 | * 0.4 08.07.1997 alternative ser12 decoding algorithm (uses delta CTS ints) |
44 | * 0.5 11.11.1997 split into separate files for ser12/par96 |
45 | * 0.6 03.08.1999 adapt to Linus' new __setup/__initcall |
46 | * removed some pre-2.2 kernel compatibility cruft |
47 | * 0.7 10.08.1999 Check if parport can do SPP and is safe to access during interrupt contexts |
48 | * 0.8 12.02.2000 adapted to softnet driver interface |
49 | * removed direct parport access, uses parport driver methods |
50 | * 0.9 03.07.2000 fix interface name handling |
51 | */ |
52 | |
53 | /*****************************************************************************/ |
54 | |
55 | #include <linux/module.h> |
56 | #include <linux/kernel.h> |
57 | #include <linux/types.h> |
58 | #include <linux/fcntl.h> |
59 | #include <linux/interrupt.h> |
60 | #include <linux/ioport.h> |
61 | #include <linux/in.h> |
62 | #include <linux/string.h> |
63 | #include <linux/init.h> |
64 | #include <linux/delay.h> |
65 | #include <linux/errno.h> |
66 | #include <linux/netdevice.h> |
67 | #include <linux/hdlcdrv.h> |
68 | #include <linux/baycom.h> |
69 | #include <linux/parport.h> |
70 | #include <linux/bitops.h> |
71 | #include <linux/jiffies.h> |
72 | |
73 | #include <linux/uaccess.h> |
74 | |
75 | /* --------------------------------------------------------------------- */ |
76 | |
77 | #define BAYCOM_DEBUG |
78 | |
79 | /* |
80 | * modem options; bit mask |
81 | */ |
82 | #define BAYCOM_OPTIONS_SOFTDCD 1 |
83 | |
84 | /* --------------------------------------------------------------------- */ |
85 | |
86 | static const char bc_drvname[] = "baycom_par" ; |
87 | static const char bc_drvinfo[] = KERN_INFO "baycom_par: (C) 1996-2000 Thomas Sailer, HB9JNX/AE4WA\n" |
88 | "baycom_par: version 0.9\n" ; |
89 | |
90 | /* --------------------------------------------------------------------- */ |
91 | |
92 | #define NR_PORTS 4 |
93 | |
94 | static struct net_device *baycom_device[NR_PORTS]; |
95 | |
96 | /* --------------------------------------------------------------------- */ |
97 | |
98 | #define PAR96_BURSTBITS 16 |
99 | #define PAR96_BURST 4 |
100 | #define PAR96_PTT 2 |
101 | #define PAR96_TXBIT 1 |
102 | #define PAR96_ACK 0x40 |
103 | #define PAR96_RXBIT 0x20 |
104 | #define PAR96_DCD 0x10 |
105 | #define PAR97_POWER 0xf8 |
106 | |
107 | /* ---------------------------------------------------------------------- */ |
108 | /* |
109 | * Information that need to be kept for each board. |
110 | */ |
111 | |
112 | struct baycom_state { |
113 | struct hdlcdrv_state hdrv; |
114 | |
115 | struct pardevice *pdev; |
116 | unsigned int options; |
117 | |
118 | struct modem_state { |
119 | short arb_divider; |
120 | unsigned char flags; |
121 | unsigned int shreg; |
122 | struct modem_state_par96 { |
123 | int dcd_count; |
124 | unsigned int dcd_shreg; |
125 | unsigned long descram; |
126 | unsigned long scram; |
127 | } par96; |
128 | } modem; |
129 | |
130 | #ifdef BAYCOM_DEBUG |
131 | struct debug_vals { |
132 | unsigned long last_jiffies; |
133 | unsigned cur_intcnt; |
134 | unsigned last_intcnt; |
135 | int cur_pllcorr; |
136 | int last_pllcorr; |
137 | } debug_vals; |
138 | #endif /* BAYCOM_DEBUG */ |
139 | }; |
140 | |
141 | /* --------------------------------------------------------------------- */ |
142 | |
143 | static inline void baycom_int_freq(struct baycom_state *bc) |
144 | { |
145 | #ifdef BAYCOM_DEBUG |
146 | unsigned long cur_jiffies = jiffies; |
147 | /* |
148 | * measure the interrupt frequency |
149 | */ |
150 | bc->debug_vals.cur_intcnt++; |
151 | if (time_after_eq(cur_jiffies, bc->debug_vals.last_jiffies + HZ)) { |
152 | bc->debug_vals.last_jiffies = cur_jiffies; |
153 | bc->debug_vals.last_intcnt = bc->debug_vals.cur_intcnt; |
154 | bc->debug_vals.cur_intcnt = 0; |
155 | bc->debug_vals.last_pllcorr = bc->debug_vals.cur_pllcorr; |
156 | bc->debug_vals.cur_pllcorr = 0; |
157 | } |
158 | #endif /* BAYCOM_DEBUG */ |
159 | } |
160 | |
161 | /* --------------------------------------------------------------------- */ |
162 | /* |
163 | * ===================== PAR96 specific routines ========================= |
164 | */ |
165 | |
166 | #define PAR96_DESCRAM_TAP1 0x20000 |
167 | #define PAR96_DESCRAM_TAP2 0x01000 |
168 | #define PAR96_DESCRAM_TAP3 0x00001 |
169 | |
170 | #define PAR96_DESCRAM_TAPSH1 17 |
171 | #define PAR96_DESCRAM_TAPSH2 12 |
172 | #define PAR96_DESCRAM_TAPSH3 0 |
173 | |
174 | #define PAR96_SCRAM_TAP1 0x20000 /* X^17 */ |
175 | #define PAR96_SCRAM_TAPN 0x00021 /* X^0+X^5 */ |
176 | |
177 | /* --------------------------------------------------------------------- */ |
178 | |
179 | static inline void par96_tx(struct net_device *dev, struct baycom_state *bc) |
180 | { |
181 | int i; |
182 | unsigned int data = hdlcdrv_getbits(s: &bc->hdrv); |
183 | struct parport *pp = bc->pdev->port; |
184 | |
185 | for(i = 0; i < PAR96_BURSTBITS; i++, data >>= 1) { |
186 | unsigned char val = PAR97_POWER; |
187 | bc->modem.par96.scram = ((bc->modem.par96.scram << 1) | |
188 | (bc->modem.par96.scram & 1)); |
189 | if (!(data & 1)) |
190 | bc->modem.par96.scram ^= 1; |
191 | if (bc->modem.par96.scram & (PAR96_SCRAM_TAP1 << 1)) |
192 | bc->modem.par96.scram ^= |
193 | (PAR96_SCRAM_TAPN << 1); |
194 | if (bc->modem.par96.scram & (PAR96_SCRAM_TAP1 << 2)) |
195 | val |= PAR96_TXBIT; |
196 | pp->ops->write_data(pp, val); |
197 | pp->ops->write_data(pp, val | PAR96_BURST); |
198 | } |
199 | } |
200 | |
201 | /* --------------------------------------------------------------------- */ |
202 | |
203 | static inline void par96_rx(struct net_device *dev, struct baycom_state *bc) |
204 | { |
205 | int i; |
206 | unsigned int data, mask, mask2, descx; |
207 | struct parport *pp = bc->pdev->port; |
208 | |
209 | /* |
210 | * do receiver; differential decode and descramble on the fly |
211 | */ |
212 | for(data = i = 0; i < PAR96_BURSTBITS; i++) { |
213 | bc->modem.par96.descram = (bc->modem.par96.descram << 1); |
214 | if (pp->ops->read_status(pp) & PAR96_RXBIT) |
215 | bc->modem.par96.descram |= 1; |
216 | descx = bc->modem.par96.descram ^ |
217 | (bc->modem.par96.descram >> 1); |
218 | /* now the diff decoded data is inverted in descram */ |
219 | pp->ops->write_data(pp, PAR97_POWER | PAR96_PTT); |
220 | descx ^= ((descx >> PAR96_DESCRAM_TAPSH1) ^ |
221 | (descx >> PAR96_DESCRAM_TAPSH2)); |
222 | data >>= 1; |
223 | if (!(descx & 1)) |
224 | data |= 0x8000; |
225 | pp->ops->write_data(pp, PAR97_POWER | PAR96_PTT | PAR96_BURST); |
226 | } |
227 | hdlcdrv_putbits(s: &bc->hdrv, bits: data); |
228 | /* |
229 | * do DCD algorithm |
230 | */ |
231 | if (bc->options & BAYCOM_OPTIONS_SOFTDCD) { |
232 | bc->modem.par96.dcd_shreg = (bc->modem.par96.dcd_shreg >> 16) |
233 | | (data << 16); |
234 | /* search for flags and set the dcd counter appropriately */ |
235 | for(mask = 0x1fe00, mask2 = 0xfc00, i = 0; |
236 | i < PAR96_BURSTBITS; i++, mask <<= 1, mask2 <<= 1) |
237 | if ((bc->modem.par96.dcd_shreg & mask) == mask2) |
238 | bc->modem.par96.dcd_count = HDLCDRV_MAXFLEN+4; |
239 | /* check for abort/noise sequences */ |
240 | for(mask = 0x1fe00, mask2 = 0x1fe00, i = 0; |
241 | i < PAR96_BURSTBITS; i++, mask <<= 1, mask2 <<= 1) |
242 | if (((bc->modem.par96.dcd_shreg & mask) == mask2) && |
243 | (bc->modem.par96.dcd_count >= 0)) |
244 | bc->modem.par96.dcd_count -= HDLCDRV_MAXFLEN-10; |
245 | /* decrement and set the dcd variable */ |
246 | if (bc->modem.par96.dcd_count >= 0) |
247 | bc->modem.par96.dcd_count -= 2; |
248 | hdlcdrv_setdcd(s: &bc->hdrv, dcd: bc->modem.par96.dcd_count > 0); |
249 | } else { |
250 | hdlcdrv_setdcd(s: &bc->hdrv, dcd: !!(pp->ops->read_status(pp) & PAR96_DCD)); |
251 | } |
252 | } |
253 | |
254 | /* --------------------------------------------------------------------- */ |
255 | |
256 | static void par96_interrupt(void *dev_id) |
257 | { |
258 | struct net_device *dev = dev_id; |
259 | struct baycom_state *bc = netdev_priv(dev); |
260 | |
261 | baycom_int_freq(bc); |
262 | /* |
263 | * check if transmitter active |
264 | */ |
265 | if (hdlcdrv_ptt(s: &bc->hdrv)) |
266 | par96_tx(dev, bc); |
267 | else { |
268 | par96_rx(dev, bc); |
269 | if (--bc->modem.arb_divider <= 0) { |
270 | bc->modem.arb_divider = 6; |
271 | local_irq_enable(); |
272 | hdlcdrv_arbitrate(dev, &bc->hdrv); |
273 | } |
274 | } |
275 | local_irq_enable(); |
276 | hdlcdrv_transmitter(dev, &bc->hdrv); |
277 | hdlcdrv_receiver(dev, &bc->hdrv); |
278 | local_irq_disable(); |
279 | } |
280 | |
281 | /* --------------------------------------------------------------------- */ |
282 | |
283 | static void par96_wakeup(void *handle) |
284 | { |
285 | struct net_device *dev = (struct net_device *)handle; |
286 | struct baycom_state *bc = netdev_priv(dev); |
287 | |
288 | printk(KERN_DEBUG "baycom_par: %s: why am I being woken up?\n" , dev->name); |
289 | if (!parport_claim(dev: bc->pdev)) |
290 | printk(KERN_DEBUG "baycom_par: %s: I'm broken.\n" , dev->name); |
291 | } |
292 | |
293 | /* --------------------------------------------------------------------- */ |
294 | |
295 | static int par96_open(struct net_device *dev) |
296 | { |
297 | struct baycom_state *bc = netdev_priv(dev); |
298 | struct pardev_cb par_cb; |
299 | struct parport *pp; |
300 | int i; |
301 | |
302 | if (!dev || !bc) |
303 | return -ENXIO; |
304 | pp = parport_find_base(dev->base_addr); |
305 | if (!pp) { |
306 | printk(KERN_ERR "baycom_par: parport at 0x%lx unknown\n" , dev->base_addr); |
307 | return -ENXIO; |
308 | } |
309 | if (pp->irq < 0) { |
310 | printk(KERN_ERR "baycom_par: parport at 0x%lx has no irq\n" , pp->base); |
311 | parport_put_port(pp); |
312 | return -ENXIO; |
313 | } |
314 | if ((~pp->modes) & (PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT)) { |
315 | printk(KERN_ERR "baycom_par: parport at 0x%lx cannot be used\n" , pp->base); |
316 | parport_put_port(pp); |
317 | return -ENXIO; |
318 | } |
319 | memset(&bc->modem, 0, sizeof(bc->modem)); |
320 | bc->hdrv.par.bitrate = 9600; |
321 | memset(&par_cb, 0, sizeof(par_cb)); |
322 | par_cb.wakeup = par96_wakeup; |
323 | par_cb.irq_func = par96_interrupt; |
324 | par_cb.private = (void *)dev; |
325 | par_cb.flags = PARPORT_DEV_EXCL; |
326 | for (i = 0; i < NR_PORTS; i++) |
327 | if (baycom_device[i] == dev) |
328 | break; |
329 | |
330 | if (i == NR_PORTS) { |
331 | pr_err("%s: no device found\n" , bc_drvname); |
332 | parport_put_port(pp); |
333 | return -ENODEV; |
334 | } |
335 | bc->pdev = parport_register_dev_model(port: pp, name: dev->name, par_dev_cb: &par_cb, cnt: i); |
336 | parport_put_port(pp); |
337 | if (!bc->pdev) { |
338 | printk(KERN_ERR "baycom_par: cannot register parport at 0x%lx\n" , dev->base_addr); |
339 | return -ENXIO; |
340 | } |
341 | if (parport_claim(dev: bc->pdev)) { |
342 | printk(KERN_ERR "baycom_par: parport at 0x%lx busy\n" , pp->base); |
343 | parport_unregister_device(dev: bc->pdev); |
344 | return -EBUSY; |
345 | } |
346 | pp = bc->pdev->port; |
347 | dev->irq = pp->irq; |
348 | pp->ops->data_forward(pp); |
349 | bc->hdrv.par.bitrate = 9600; |
350 | pp->ops->write_data(pp, PAR96_PTT | PAR97_POWER); /* switch off PTT */ |
351 | pp->ops->enable_irq(pp); |
352 | printk(KERN_INFO "%s: par96 at iobase 0x%lx irq %u options 0x%x\n" , |
353 | bc_drvname, dev->base_addr, dev->irq, bc->options); |
354 | return 0; |
355 | } |
356 | |
357 | /* --------------------------------------------------------------------- */ |
358 | |
359 | static int par96_close(struct net_device *dev) |
360 | { |
361 | struct baycom_state *bc = netdev_priv(dev); |
362 | struct parport *pp; |
363 | |
364 | if (!dev || !bc) |
365 | return -EINVAL; |
366 | pp = bc->pdev->port; |
367 | /* disable interrupt */ |
368 | pp->ops->disable_irq(pp); |
369 | /* switch off PTT */ |
370 | pp->ops->write_data(pp, PAR96_PTT | PAR97_POWER); |
371 | parport_release(dev: bc->pdev); |
372 | parport_unregister_device(dev: bc->pdev); |
373 | printk(KERN_INFO "%s: close par96 at iobase 0x%lx irq %u\n" , |
374 | bc_drvname, dev->base_addr, dev->irq); |
375 | return 0; |
376 | } |
377 | |
378 | /* --------------------------------------------------------------------- */ |
379 | /* |
380 | * ===================== hdlcdrv driver interface ========================= |
381 | */ |
382 | |
383 | static int baycom_ioctl(struct net_device *dev, void __user *data, |
384 | struct hdlcdrv_ioctl *hi, int cmd); |
385 | |
386 | /* --------------------------------------------------------------------- */ |
387 | |
388 | static const struct hdlcdrv_ops par96_ops = { |
389 | .drvname = bc_drvname, |
390 | .drvinfo = bc_drvinfo, |
391 | .open = par96_open, |
392 | .close = par96_close, |
393 | .ioctl = baycom_ioctl |
394 | }; |
395 | |
396 | /* --------------------------------------------------------------------- */ |
397 | |
398 | static int baycom_setmode(struct baycom_state *bc, const char *modestr) |
399 | { |
400 | if (!strncmp(modestr, "picpar" , 6)) |
401 | bc->options = 0; |
402 | else if (!strncmp(modestr, "par96" , 5)) |
403 | bc->options = BAYCOM_OPTIONS_SOFTDCD; |
404 | else |
405 | bc->options = !!strchr(modestr, '*'); |
406 | return 0; |
407 | } |
408 | |
409 | /* --------------------------------------------------------------------- */ |
410 | |
411 | static int baycom_ioctl(struct net_device *dev, void __user *data, |
412 | struct hdlcdrv_ioctl *hi, int cmd) |
413 | { |
414 | struct baycom_state *bc; |
415 | struct baycom_ioctl bi; |
416 | |
417 | if (!dev) |
418 | return -EINVAL; |
419 | |
420 | bc = netdev_priv(dev); |
421 | BUG_ON(bc->hdrv.magic != HDLCDRV_MAGIC); |
422 | |
423 | if (cmd != SIOCDEVPRIVATE) |
424 | return -ENOIOCTLCMD; |
425 | switch (hi->cmd) { |
426 | default: |
427 | break; |
428 | |
429 | case HDLCDRVCTL_GETMODE: |
430 | strcpy(p: hi->data.modename, q: bc->options ? "par96" : "picpar" ); |
431 | if (copy_to_user(to: data, from: hi, n: sizeof(struct hdlcdrv_ioctl))) |
432 | return -EFAULT; |
433 | return 0; |
434 | |
435 | case HDLCDRVCTL_SETMODE: |
436 | if (netif_running(dev) || !capable(CAP_NET_ADMIN)) |
437 | return -EACCES; |
438 | hi->data.modename[sizeof(hi->data.modename)-1] = '\0'; |
439 | return baycom_setmode(bc, modestr: hi->data.modename); |
440 | |
441 | case HDLCDRVCTL_MODELIST: |
442 | strcpy(p: hi->data.modename, q: "par96,picpar" ); |
443 | if (copy_to_user(to: data, from: hi, n: sizeof(struct hdlcdrv_ioctl))) |
444 | return -EFAULT; |
445 | return 0; |
446 | |
447 | case HDLCDRVCTL_MODEMPARMASK: |
448 | return HDLCDRV_PARMASK_IOBASE; |
449 | |
450 | } |
451 | |
452 | if (copy_from_user(to: &bi, from: data, n: sizeof(bi))) |
453 | return -EFAULT; |
454 | switch (bi.cmd) { |
455 | default: |
456 | return -ENOIOCTLCMD; |
457 | |
458 | #ifdef BAYCOM_DEBUG |
459 | case BAYCOMCTL_GETDEBUG: |
460 | bi.data.dbg.debug1 = bc->hdrv.ptt_keyed; |
461 | bi.data.dbg.debug2 = bc->debug_vals.last_intcnt; |
462 | bi.data.dbg.debug3 = bc->debug_vals.last_pllcorr; |
463 | break; |
464 | #endif /* BAYCOM_DEBUG */ |
465 | |
466 | } |
467 | if (copy_to_user(to: data, from: &bi, n: sizeof(bi))) |
468 | return -EFAULT; |
469 | return 0; |
470 | |
471 | } |
472 | |
473 | /* --------------------------------------------------------------------- */ |
474 | |
475 | /* |
476 | * command line settable parameters |
477 | */ |
478 | static char *mode[NR_PORTS] = { "picpar" , }; |
479 | static int iobase[NR_PORTS] = { 0x378, }; |
480 | |
481 | module_param_array(mode, charp, NULL, 0); |
482 | MODULE_PARM_DESC(mode, "baycom operating mode; eg. par96 or picpar" ); |
483 | module_param_hw_array(iobase, int, ioport, NULL, 0); |
484 | MODULE_PARM_DESC(iobase, "baycom io base address" ); |
485 | |
486 | MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu" ); |
487 | MODULE_DESCRIPTION("Baycom par96 and picpar amateur radio modem driver" ); |
488 | MODULE_LICENSE("GPL" ); |
489 | |
490 | /* --------------------------------------------------------------------- */ |
491 | |
492 | static int baycom_par_probe(struct pardevice *par_dev) |
493 | { |
494 | struct device_driver *drv = par_dev->dev.driver; |
495 | int len = strlen(drv->name); |
496 | |
497 | if (strncmp(par_dev->name, drv->name, len)) |
498 | return -ENODEV; |
499 | |
500 | return 0; |
501 | } |
502 | |
503 | static struct parport_driver baycom_par_driver = { |
504 | .name = "bcp" , |
505 | .probe = baycom_par_probe, |
506 | .devmodel = true, |
507 | }; |
508 | |
509 | static int __init init_baycompar(void) |
510 | { |
511 | int i, found = 0, ret; |
512 | char set_hw = 1; |
513 | |
514 | printk(bc_drvinfo); |
515 | |
516 | ret = parport_register_driver(&baycom_par_driver); |
517 | if (ret) |
518 | return ret; |
519 | |
520 | /* |
521 | * register net devices |
522 | */ |
523 | for (i = 0; i < NR_PORTS; i++) { |
524 | struct net_device *dev; |
525 | struct baycom_state *bc; |
526 | char ifname[IFNAMSIZ]; |
527 | |
528 | sprintf(buf: ifname, fmt: "bcp%d" , i); |
529 | |
530 | if (!mode[i]) |
531 | set_hw = 0; |
532 | if (!set_hw) |
533 | iobase[i] = 0; |
534 | |
535 | dev = hdlcdrv_register(ops: &par96_ops, |
536 | privsize: sizeof(struct baycom_state), |
537 | ifname, baseaddr: iobase[i], irq: 0, dma: 0); |
538 | if (IS_ERR(ptr: dev)) |
539 | break; |
540 | |
541 | bc = netdev_priv(dev); |
542 | if (set_hw && baycom_setmode(bc, modestr: mode[i])) |
543 | set_hw = 0; |
544 | found++; |
545 | baycom_device[i] = dev; |
546 | } |
547 | |
548 | if (!found) { |
549 | parport_unregister_driver(&baycom_par_driver); |
550 | return -ENXIO; |
551 | } |
552 | return 0; |
553 | } |
554 | |
555 | static void __exit cleanup_baycompar(void) |
556 | { |
557 | int i; |
558 | |
559 | for(i = 0; i < NR_PORTS; i++) { |
560 | struct net_device *dev = baycom_device[i]; |
561 | |
562 | if (dev) |
563 | hdlcdrv_unregister(dev); |
564 | } |
565 | parport_unregister_driver(&baycom_par_driver); |
566 | } |
567 | |
568 | module_init(init_baycompar); |
569 | module_exit(cleanup_baycompar); |
570 | |
571 | /* --------------------------------------------------------------------- */ |
572 | |
573 | #ifndef MODULE |
574 | |
575 | /* |
576 | * format: baycom_par=io,mode |
577 | * mode: par96,picpar |
578 | */ |
579 | |
580 | static int __init baycom_par_setup(char *str) |
581 | { |
582 | static unsigned nr_dev; |
583 | int ints[2]; |
584 | |
585 | if (nr_dev >= NR_PORTS) |
586 | return 0; |
587 | str = get_options(str, nints: 2, ints); |
588 | if (ints[0] < 1) |
589 | return 0; |
590 | mode[nr_dev] = str; |
591 | iobase[nr_dev] = ints[1]; |
592 | nr_dev++; |
593 | return 1; |
594 | } |
595 | |
596 | __setup("baycom_par=" , baycom_par_setup); |
597 | |
598 | #endif /* MODULE */ |
599 | /* --------------------------------------------------------------------- */ |
600 | |