1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /*****************************************************************************/ |
3 | |
4 | /* |
5 | * baycom_ser_hdx.c -- baycom ser12 halfduplex 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 | * ser12: This is a very simple 1200 baud AFSK modem. The modem consists only |
16 | * of a modulator/demodulator chip, usually a TI TCM3105. The computer |
17 | * is responsible for regenerating the receiver bit clock, as well as |
18 | * for handling the HDLC protocol. The modem connects to a serial port, |
19 | * hence the name. Since the serial port is not used as an async serial |
20 | * port, the kernel driver for serial ports cannot be used, and this |
21 | * driver only supports standard serial hardware (8250, 16450, 16550A) |
22 | * |
23 | * Command line options (insmod command line) |
24 | * |
25 | * mode ser12 hardware DCD |
26 | * ser12* software DCD |
27 | * ser12@ hardware/software DCD, i.e. no explicit DCD signal but hardware |
28 | * mutes audio input to the modem |
29 | * ser12+ hardware DCD, inverted signal at DCD pin |
30 | * iobase base address of the port; common values are 0x3f8, 0x2f8, 0x3e8, 0x2e8 |
31 | * irq interrupt line of the port; common values are 4,3 |
32 | * |
33 | * History: |
34 | * 0.1 26.06.1996 Adapted from baycom.c and made network driver interface |
35 | * 18.10.1996 Changed to new user space access routines (copy_{to,from}_user) |
36 | * 0.3 26.04.1997 init code/data tagged |
37 | * 0.4 08.07.1997 alternative ser12 decoding algorithm (uses delta CTS ints) |
38 | * 0.5 11.11.1997 ser12/par96 split into separate files |
39 | * 0.6 14.04.1998 cleanups |
40 | * 0.7 03.08.1999 adapt to Linus' new __setup/__initcall |
41 | * 0.8 10.08.1999 use module_init/module_exit |
42 | * 0.9 12.02.2000 adapted to softnet driver interface |
43 | * 0.10 03.07.2000 fix interface name handling |
44 | */ |
45 | |
46 | /*****************************************************************************/ |
47 | |
48 | #include <linux/capability.h> |
49 | #include <linux/module.h> |
50 | #include <linux/ioport.h> |
51 | #include <linux/string.h> |
52 | #include <linux/init.h> |
53 | #include <linux/interrupt.h> |
54 | #include <linux/uaccess.h> |
55 | #include <asm/io.h> |
56 | #include <linux/hdlcdrv.h> |
57 | #include <linux/baycom.h> |
58 | #include <linux/jiffies.h> |
59 | |
60 | /* --------------------------------------------------------------------- */ |
61 | |
62 | #define BAYCOM_DEBUG |
63 | |
64 | /* --------------------------------------------------------------------- */ |
65 | |
66 | static const char bc_drvname[] = "baycom_ser_hdx" ; |
67 | static const char bc_drvinfo[] = KERN_INFO "baycom_ser_hdx: (C) 1996-2000 Thomas Sailer, HB9JNX/AE4WA\n" |
68 | "baycom_ser_hdx: version 0.10\n" ; |
69 | |
70 | /* --------------------------------------------------------------------- */ |
71 | |
72 | #define NR_PORTS 4 |
73 | |
74 | static struct net_device *baycom_device[NR_PORTS]; |
75 | |
76 | /* --------------------------------------------------------------------- */ |
77 | |
78 | #define RBR(iobase) (iobase+0) |
79 | #define THR(iobase) (iobase+0) |
80 | #define IER(iobase) (iobase+1) |
81 | #define IIR(iobase) (iobase+2) |
82 | #define FCR(iobase) (iobase+2) |
83 | #define LCR(iobase) (iobase+3) |
84 | #define MCR(iobase) (iobase+4) |
85 | #define LSR(iobase) (iobase+5) |
86 | #define MSR(iobase) (iobase+6) |
87 | #define SCR(iobase) (iobase+7) |
88 | #define DLL(iobase) (iobase+0) |
89 | #define DLM(iobase) (iobase+1) |
90 | |
91 | #define SER12_EXTENT 8 |
92 | |
93 | /* ---------------------------------------------------------------------- */ |
94 | /* |
95 | * Information that need to be kept for each board. |
96 | */ |
97 | |
98 | struct baycom_state { |
99 | struct hdlcdrv_state hdrv; |
100 | |
101 | int opt_dcd; |
102 | |
103 | struct modem_state { |
104 | short arb_divider; |
105 | unsigned char flags; |
106 | unsigned int shreg; |
107 | struct modem_state_ser12 { |
108 | unsigned char tx_bit; |
109 | int dcd_sum0, dcd_sum1, dcd_sum2; |
110 | unsigned char last_sample; |
111 | unsigned char last_rxbit; |
112 | unsigned int dcd_shreg; |
113 | unsigned int dcd_time; |
114 | unsigned int bit_pll; |
115 | unsigned char interm_sample; |
116 | } ser12; |
117 | } modem; |
118 | |
119 | #ifdef BAYCOM_DEBUG |
120 | struct debug_vals { |
121 | unsigned long last_jiffies; |
122 | unsigned cur_intcnt; |
123 | unsigned last_intcnt; |
124 | int cur_pllcorr; |
125 | int last_pllcorr; |
126 | } debug_vals; |
127 | #endif /* BAYCOM_DEBUG */ |
128 | }; |
129 | |
130 | /* --------------------------------------------------------------------- */ |
131 | |
132 | static inline void baycom_int_freq(struct baycom_state *bc) |
133 | { |
134 | #ifdef BAYCOM_DEBUG |
135 | unsigned long cur_jiffies = jiffies; |
136 | /* |
137 | * measure the interrupt frequency |
138 | */ |
139 | bc->debug_vals.cur_intcnt++; |
140 | if (time_after_eq(cur_jiffies, bc->debug_vals.last_jiffies + HZ)) { |
141 | bc->debug_vals.last_jiffies = cur_jiffies; |
142 | bc->debug_vals.last_intcnt = bc->debug_vals.cur_intcnt; |
143 | bc->debug_vals.cur_intcnt = 0; |
144 | bc->debug_vals.last_pllcorr = bc->debug_vals.cur_pllcorr; |
145 | bc->debug_vals.cur_pllcorr = 0; |
146 | } |
147 | #endif /* BAYCOM_DEBUG */ |
148 | } |
149 | |
150 | /* --------------------------------------------------------------------- */ |
151 | /* |
152 | * ===================== SER12 specific routines ========================= |
153 | */ |
154 | |
155 | static inline void ser12_set_divisor(struct net_device *dev, |
156 | unsigned char divisor) |
157 | { |
158 | outb(value: 0x81, LCR(dev->base_addr)); /* DLAB = 1 */ |
159 | outb(value: divisor, DLL(dev->base_addr)); |
160 | outb(value: 0, DLM(dev->base_addr)); |
161 | outb(value: 0x01, LCR(dev->base_addr)); /* word length = 6 */ |
162 | /* |
163 | * make sure the next interrupt is generated; |
164 | * 0 must be used to power the modem; the modem draws its |
165 | * power from the TxD line |
166 | */ |
167 | outb(value: 0x00, THR(dev->base_addr)); |
168 | /* |
169 | * it is important not to set the divider while transmitting; |
170 | * this reportedly makes some UARTs generating interrupts |
171 | * in the hundredthousands per second region |
172 | * Reported by: Ignacio.Arenaza@studi.epfl.ch (Ignacio Arenaza Nuno) |
173 | */ |
174 | } |
175 | |
176 | /* --------------------------------------------------------------------- */ |
177 | |
178 | /* |
179 | * must call the TX arbitrator every 10ms |
180 | */ |
181 | #define SER12_ARB_DIVIDER(bc) (bc->opt_dcd ? 24 : 36) |
182 | |
183 | #define SER12_DCD_INTERVAL(bc) (bc->opt_dcd ? 12 : 240) |
184 | |
185 | static inline void ser12_tx(struct net_device *dev, struct baycom_state *bc) |
186 | { |
187 | /* one interrupt per channel bit */ |
188 | ser12_set_divisor(dev, divisor: 12); |
189 | /* |
190 | * first output the last bit (!) then call HDLC transmitter, |
191 | * since this may take quite long |
192 | */ |
193 | outb(value: 0x0e | (!!bc->modem.ser12.tx_bit), MCR(dev->base_addr)); |
194 | if (bc->modem.shreg <= 1) |
195 | bc->modem.shreg = 0x10000 | hdlcdrv_getbits(s: &bc->hdrv); |
196 | bc->modem.ser12.tx_bit = !(bc->modem.ser12.tx_bit ^ |
197 | (bc->modem.shreg & 1)); |
198 | bc->modem.shreg >>= 1; |
199 | } |
200 | |
201 | /* --------------------------------------------------------------------- */ |
202 | |
203 | static inline void ser12_rx(struct net_device *dev, struct baycom_state *bc) |
204 | { |
205 | unsigned char cur_s; |
206 | /* |
207 | * do demodulator |
208 | */ |
209 | cur_s = inb(MSR(dev->base_addr)) & 0x10; /* the CTS line */ |
210 | hdlcdrv_channelbit(s: &bc->hdrv, bit: cur_s); |
211 | bc->modem.ser12.dcd_shreg = (bc->modem.ser12.dcd_shreg << 1) | |
212 | (cur_s != bc->modem.ser12.last_sample); |
213 | bc->modem.ser12.last_sample = cur_s; |
214 | if(bc->modem.ser12.dcd_shreg & 1) { |
215 | if (!bc->opt_dcd) { |
216 | unsigned int dcdspos, dcdsneg; |
217 | |
218 | dcdspos = dcdsneg = 0; |
219 | dcdspos += ((bc->modem.ser12.dcd_shreg >> 1) & 1); |
220 | if (!(bc->modem.ser12.dcd_shreg & 0x7ffffffe)) |
221 | dcdspos += 2; |
222 | dcdsneg += ((bc->modem.ser12.dcd_shreg >> 2) & 1); |
223 | dcdsneg += ((bc->modem.ser12.dcd_shreg >> 3) & 1); |
224 | dcdsneg += ((bc->modem.ser12.dcd_shreg >> 4) & 1); |
225 | |
226 | bc->modem.ser12.dcd_sum0 += 16*dcdspos - dcdsneg; |
227 | } else |
228 | bc->modem.ser12.dcd_sum0--; |
229 | } |
230 | if(!bc->modem.ser12.dcd_time) { |
231 | hdlcdrv_setdcd(s: &bc->hdrv, dcd: (bc->modem.ser12.dcd_sum0 + |
232 | bc->modem.ser12.dcd_sum1 + |
233 | bc->modem.ser12.dcd_sum2) < 0); |
234 | bc->modem.ser12.dcd_sum2 = bc->modem.ser12.dcd_sum1; |
235 | bc->modem.ser12.dcd_sum1 = bc->modem.ser12.dcd_sum0; |
236 | /* offset to ensure DCD off on silent input */ |
237 | bc->modem.ser12.dcd_sum0 = 2; |
238 | bc->modem.ser12.dcd_time = SER12_DCD_INTERVAL(bc); |
239 | } |
240 | bc->modem.ser12.dcd_time--; |
241 | if (!bc->opt_dcd) { |
242 | /* |
243 | * PLL code for the improved software DCD algorithm |
244 | */ |
245 | if (bc->modem.ser12.interm_sample) { |
246 | /* |
247 | * intermediate sample; set timing correction to normal |
248 | */ |
249 | ser12_set_divisor(dev, divisor: 4); |
250 | } else { |
251 | /* |
252 | * do PLL correction and call HDLC receiver |
253 | */ |
254 | switch (bc->modem.ser12.dcd_shreg & 7) { |
255 | case 1: /* transition too late */ |
256 | ser12_set_divisor(dev, divisor: 5); |
257 | #ifdef BAYCOM_DEBUG |
258 | bc->debug_vals.cur_pllcorr++; |
259 | #endif /* BAYCOM_DEBUG */ |
260 | break; |
261 | case 4: /* transition too early */ |
262 | ser12_set_divisor(dev, divisor: 3); |
263 | #ifdef BAYCOM_DEBUG |
264 | bc->debug_vals.cur_pllcorr--; |
265 | #endif /* BAYCOM_DEBUG */ |
266 | break; |
267 | default: |
268 | ser12_set_divisor(dev, divisor: 4); |
269 | break; |
270 | } |
271 | bc->modem.shreg >>= 1; |
272 | if (bc->modem.ser12.last_sample == |
273 | bc->modem.ser12.last_rxbit) |
274 | bc->modem.shreg |= 0x10000; |
275 | bc->modem.ser12.last_rxbit = |
276 | bc->modem.ser12.last_sample; |
277 | } |
278 | if (++bc->modem.ser12.interm_sample >= 3) |
279 | bc->modem.ser12.interm_sample = 0; |
280 | /* |
281 | * DCD stuff |
282 | */ |
283 | if (bc->modem.ser12.dcd_shreg & 1) { |
284 | unsigned int dcdspos, dcdsneg; |
285 | |
286 | dcdspos = dcdsneg = 0; |
287 | dcdspos += ((bc->modem.ser12.dcd_shreg >> 1) & 1); |
288 | dcdspos += (!(bc->modem.ser12.dcd_shreg & 0x7ffffffe)) |
289 | << 1; |
290 | dcdsneg += ((bc->modem.ser12.dcd_shreg >> 2) & 1); |
291 | dcdsneg += ((bc->modem.ser12.dcd_shreg >> 3) & 1); |
292 | dcdsneg += ((bc->modem.ser12.dcd_shreg >> 4) & 1); |
293 | |
294 | bc->modem.ser12.dcd_sum0 += 16*dcdspos - dcdsneg; |
295 | } |
296 | } else { |
297 | /* |
298 | * PLL algorithm for the hardware squelch DCD algorithm |
299 | */ |
300 | if (bc->modem.ser12.interm_sample) { |
301 | /* |
302 | * intermediate sample; set timing correction to normal |
303 | */ |
304 | ser12_set_divisor(dev, divisor: 6); |
305 | } else { |
306 | /* |
307 | * do PLL correction and call HDLC receiver |
308 | */ |
309 | switch (bc->modem.ser12.dcd_shreg & 3) { |
310 | case 1: /* transition too late */ |
311 | ser12_set_divisor(dev, divisor: 7); |
312 | #ifdef BAYCOM_DEBUG |
313 | bc->debug_vals.cur_pllcorr++; |
314 | #endif /* BAYCOM_DEBUG */ |
315 | break; |
316 | case 2: /* transition too early */ |
317 | ser12_set_divisor(dev, divisor: 5); |
318 | #ifdef BAYCOM_DEBUG |
319 | bc->debug_vals.cur_pllcorr--; |
320 | #endif /* BAYCOM_DEBUG */ |
321 | break; |
322 | default: |
323 | ser12_set_divisor(dev, divisor: 6); |
324 | break; |
325 | } |
326 | bc->modem.shreg >>= 1; |
327 | if (bc->modem.ser12.last_sample == |
328 | bc->modem.ser12.last_rxbit) |
329 | bc->modem.shreg |= 0x10000; |
330 | bc->modem.ser12.last_rxbit = |
331 | bc->modem.ser12.last_sample; |
332 | } |
333 | bc->modem.ser12.interm_sample = !bc->modem.ser12.interm_sample; |
334 | /* |
335 | * DCD stuff |
336 | */ |
337 | bc->modem.ser12.dcd_sum0 -= (bc->modem.ser12.dcd_shreg & 1); |
338 | } |
339 | outb(value: 0x0d, MCR(dev->base_addr)); /* transmitter off */ |
340 | if (bc->modem.shreg & 1) { |
341 | hdlcdrv_putbits(s: &bc->hdrv, bits: bc->modem.shreg >> 1); |
342 | bc->modem.shreg = 0x10000; |
343 | } |
344 | if(!bc->modem.ser12.dcd_time) { |
345 | if (bc->opt_dcd & 1) |
346 | hdlcdrv_setdcd(s: &bc->hdrv, dcd: !((inb(MSR(dev->base_addr)) ^ bc->opt_dcd) & 0x80)); |
347 | else |
348 | hdlcdrv_setdcd(s: &bc->hdrv, dcd: (bc->modem.ser12.dcd_sum0 + |
349 | bc->modem.ser12.dcd_sum1 + |
350 | bc->modem.ser12.dcd_sum2) < 0); |
351 | bc->modem.ser12.dcd_sum2 = bc->modem.ser12.dcd_sum1; |
352 | bc->modem.ser12.dcd_sum1 = bc->modem.ser12.dcd_sum0; |
353 | /* offset to ensure DCD off on silent input */ |
354 | bc->modem.ser12.dcd_sum0 = 2; |
355 | bc->modem.ser12.dcd_time = SER12_DCD_INTERVAL(bc); |
356 | } |
357 | bc->modem.ser12.dcd_time--; |
358 | } |
359 | |
360 | /* --------------------------------------------------------------------- */ |
361 | |
362 | static irqreturn_t ser12_interrupt(int irq, void *dev_id) |
363 | { |
364 | struct net_device *dev = (struct net_device *)dev_id; |
365 | struct baycom_state *bc = netdev_priv(dev); |
366 | unsigned char iir; |
367 | |
368 | if (!dev || !bc || bc->hdrv.magic != HDLCDRV_MAGIC) |
369 | return IRQ_NONE; |
370 | /* fast way out */ |
371 | if ((iir = inb(IIR(dev->base_addr))) & 1) |
372 | return IRQ_NONE; |
373 | baycom_int_freq(bc); |
374 | do { |
375 | switch (iir & 6) { |
376 | case 6: |
377 | inb(LSR(dev->base_addr)); |
378 | break; |
379 | |
380 | case 4: |
381 | inb(RBR(dev->base_addr)); |
382 | break; |
383 | |
384 | case 2: |
385 | /* |
386 | * check if transmitter active |
387 | */ |
388 | if (hdlcdrv_ptt(s: &bc->hdrv)) |
389 | ser12_tx(dev, bc); |
390 | else { |
391 | ser12_rx(dev, bc); |
392 | bc->modem.arb_divider--; |
393 | } |
394 | outb(value: 0x00, THR(dev->base_addr)); |
395 | break; |
396 | |
397 | default: |
398 | inb(MSR(dev->base_addr)); |
399 | break; |
400 | } |
401 | iir = inb(IIR(dev->base_addr)); |
402 | } while (!(iir & 1)); |
403 | if (bc->modem.arb_divider <= 0) { |
404 | bc->modem.arb_divider = SER12_ARB_DIVIDER(bc); |
405 | local_irq_enable(); |
406 | hdlcdrv_arbitrate(dev, &bc->hdrv); |
407 | } |
408 | local_irq_enable(); |
409 | hdlcdrv_transmitter(dev, &bc->hdrv); |
410 | hdlcdrv_receiver(dev, &bc->hdrv); |
411 | local_irq_disable(); |
412 | return IRQ_HANDLED; |
413 | } |
414 | |
415 | /* --------------------------------------------------------------------- */ |
416 | |
417 | enum uart { c_uart_unknown, c_uart_8250, |
418 | c_uart_16450, c_uart_16550, c_uart_16550A}; |
419 | static const char *uart_str[] = { |
420 | "unknown" , "8250" , "16450" , "16550" , "16550A" |
421 | }; |
422 | |
423 | static enum uart ser12_check_uart(unsigned int iobase) |
424 | { |
425 | unsigned char b1,b2,b3; |
426 | enum uart u; |
427 | enum uart uart_tab[] = |
428 | { c_uart_16450, c_uart_unknown, c_uart_16550, c_uart_16550A }; |
429 | |
430 | b1 = inb(MCR(iobase)); |
431 | outb(value: b1 | 0x10, MCR(iobase)); /* loopback mode */ |
432 | b2 = inb(MSR(iobase)); |
433 | outb(value: 0x1a, MCR(iobase)); |
434 | b3 = inb(MSR(iobase)) & 0xf0; |
435 | outb(value: b1, MCR(iobase)); /* restore old values */ |
436 | outb(value: b2, MSR(iobase)); |
437 | if (b3 != 0x90) |
438 | return c_uart_unknown; |
439 | inb(RBR(iobase)); |
440 | inb(RBR(iobase)); |
441 | outb(value: 0x01, FCR(iobase)); /* enable FIFOs */ |
442 | u = uart_tab[(inb(IIR(iobase)) >> 6) & 3]; |
443 | if (u == c_uart_16450) { |
444 | outb(value: 0x5a, SCR(iobase)); |
445 | b1 = inb(SCR(iobase)); |
446 | outb(value: 0xa5, SCR(iobase)); |
447 | b2 = inb(SCR(iobase)); |
448 | if ((b1 != 0x5a) || (b2 != 0xa5)) |
449 | u = c_uart_8250; |
450 | } |
451 | return u; |
452 | } |
453 | |
454 | /* --------------------------------------------------------------------- */ |
455 | |
456 | static int ser12_open(struct net_device *dev) |
457 | { |
458 | struct baycom_state *bc = netdev_priv(dev); |
459 | enum uart u; |
460 | |
461 | if (!dev || !bc) |
462 | return -ENXIO; |
463 | if (!dev->base_addr || dev->base_addr > 0x1000-SER12_EXTENT || |
464 | dev->irq < 2 || dev->irq > 15) |
465 | return -ENXIO; |
466 | if (!request_region(dev->base_addr, SER12_EXTENT, "baycom_ser12" )) |
467 | return -EACCES; |
468 | memset(&bc->modem, 0, sizeof(bc->modem)); |
469 | bc->hdrv.par.bitrate = 1200; |
470 | if ((u = ser12_check_uart(iobase: dev->base_addr)) == c_uart_unknown) { |
471 | release_region(dev->base_addr, SER12_EXTENT); |
472 | return -EIO; |
473 | } |
474 | outb(value: 0, FCR(dev->base_addr)); /* disable FIFOs */ |
475 | outb(value: 0x0d, MCR(dev->base_addr)); |
476 | outb(value: 0, IER(dev->base_addr)); |
477 | if (request_irq(irq: dev->irq, handler: ser12_interrupt, IRQF_SHARED, |
478 | name: "baycom_ser12" , dev)) { |
479 | release_region(dev->base_addr, SER12_EXTENT); |
480 | return -EBUSY; |
481 | } |
482 | /* |
483 | * enable transmitter empty interrupt |
484 | */ |
485 | outb(value: 2, IER(dev->base_addr)); |
486 | /* |
487 | * set the SIO to 6 Bits/character and 19200 or 28800 baud, so that |
488 | * we get exactly (hopefully) 2 or 3 interrupts per radio symbol, |
489 | * depending on the usage of the software DCD routine |
490 | */ |
491 | ser12_set_divisor(dev, divisor: bc->opt_dcd ? 6 : 4); |
492 | printk(KERN_INFO "%s: ser12 at iobase 0x%lx irq %u uart %s\n" , |
493 | bc_drvname, dev->base_addr, dev->irq, uart_str[u]); |
494 | return 0; |
495 | } |
496 | |
497 | /* --------------------------------------------------------------------- */ |
498 | |
499 | static int ser12_close(struct net_device *dev) |
500 | { |
501 | struct baycom_state *bc = netdev_priv(dev); |
502 | |
503 | if (!dev || !bc) |
504 | return -EINVAL; |
505 | /* |
506 | * disable interrupts |
507 | */ |
508 | outb(value: 0, IER(dev->base_addr)); |
509 | outb(value: 1, MCR(dev->base_addr)); |
510 | free_irq(dev->irq, dev); |
511 | release_region(dev->base_addr, SER12_EXTENT); |
512 | printk(KERN_INFO "%s: close ser12 at iobase 0x%lx irq %u\n" , |
513 | bc_drvname, dev->base_addr, dev->irq); |
514 | return 0; |
515 | } |
516 | |
517 | /* --------------------------------------------------------------------- */ |
518 | /* |
519 | * ===================== hdlcdrv driver interface ========================= |
520 | */ |
521 | |
522 | /* --------------------------------------------------------------------- */ |
523 | |
524 | static int baycom_ioctl(struct net_device *dev, void __user *data, |
525 | struct hdlcdrv_ioctl *hi, int cmd); |
526 | |
527 | /* --------------------------------------------------------------------- */ |
528 | |
529 | static const struct hdlcdrv_ops ser12_ops = { |
530 | .drvname = bc_drvname, |
531 | .drvinfo = bc_drvinfo, |
532 | .open = ser12_open, |
533 | .close = ser12_close, |
534 | .ioctl = baycom_ioctl, |
535 | }; |
536 | |
537 | /* --------------------------------------------------------------------- */ |
538 | |
539 | static int baycom_setmode(struct baycom_state *bc, const char *modestr) |
540 | { |
541 | if (strchr(modestr, '*')) |
542 | bc->opt_dcd = 0; |
543 | else if (strchr(modestr, '+')) |
544 | bc->opt_dcd = -1; |
545 | else if (strchr(modestr, '@')) |
546 | bc->opt_dcd = -2; |
547 | else |
548 | bc->opt_dcd = 1; |
549 | return 0; |
550 | } |
551 | |
552 | /* --------------------------------------------------------------------- */ |
553 | |
554 | static int baycom_ioctl(struct net_device *dev, void __user *data, |
555 | struct hdlcdrv_ioctl *hi, int cmd) |
556 | { |
557 | struct baycom_state *bc; |
558 | struct baycom_ioctl bi; |
559 | |
560 | if (!dev) |
561 | return -EINVAL; |
562 | |
563 | bc = netdev_priv(dev); |
564 | BUG_ON(bc->hdrv.magic != HDLCDRV_MAGIC); |
565 | |
566 | if (cmd != SIOCDEVPRIVATE) |
567 | return -ENOIOCTLCMD; |
568 | switch (hi->cmd) { |
569 | default: |
570 | break; |
571 | |
572 | case HDLCDRVCTL_GETMODE: |
573 | strcpy(p: hi->data.modename, q: "ser12" ); |
574 | if (bc->opt_dcd <= 0) |
575 | strcat(p: hi->data.modename, q: (!bc->opt_dcd) ? "*" : (bc->opt_dcd == -2) ? "@" : "+" ); |
576 | if (copy_to_user(to: data, from: hi, n: sizeof(struct hdlcdrv_ioctl))) |
577 | return -EFAULT; |
578 | return 0; |
579 | |
580 | case HDLCDRVCTL_SETMODE: |
581 | if (netif_running(dev) || !capable(CAP_NET_ADMIN)) |
582 | return -EACCES; |
583 | hi->data.modename[sizeof(hi->data.modename)-1] = '\0'; |
584 | return baycom_setmode(bc, modestr: hi->data.modename); |
585 | |
586 | case HDLCDRVCTL_MODELIST: |
587 | strcpy(p: hi->data.modename, q: "ser12" ); |
588 | if (copy_to_user(to: data, from: hi, n: sizeof(struct hdlcdrv_ioctl))) |
589 | return -EFAULT; |
590 | return 0; |
591 | |
592 | case HDLCDRVCTL_MODEMPARMASK: |
593 | return HDLCDRV_PARMASK_IOBASE | HDLCDRV_PARMASK_IRQ; |
594 | |
595 | } |
596 | |
597 | if (copy_from_user(to: &bi, from: data, n: sizeof(bi))) |
598 | return -EFAULT; |
599 | switch (bi.cmd) { |
600 | default: |
601 | return -ENOIOCTLCMD; |
602 | |
603 | #ifdef BAYCOM_DEBUG |
604 | case BAYCOMCTL_GETDEBUG: |
605 | bi.data.dbg.debug1 = bc->hdrv.ptt_keyed; |
606 | bi.data.dbg.debug2 = bc->debug_vals.last_intcnt; |
607 | bi.data.dbg.debug3 = bc->debug_vals.last_pllcorr; |
608 | break; |
609 | #endif /* BAYCOM_DEBUG */ |
610 | |
611 | } |
612 | if (copy_to_user(to: data, from: &bi, n: sizeof(bi))) |
613 | return -EFAULT; |
614 | return 0; |
615 | |
616 | } |
617 | |
618 | /* --------------------------------------------------------------------- */ |
619 | |
620 | /* |
621 | * command line settable parameters |
622 | */ |
623 | static char *mode[NR_PORTS] = { "ser12*" , }; |
624 | static int iobase[NR_PORTS] = { 0x3f8, }; |
625 | static int irq[NR_PORTS] = { 4, }; |
626 | |
627 | module_param_array(mode, charp, NULL, 0); |
628 | MODULE_PARM_DESC(mode, "baycom operating mode; * for software DCD" ); |
629 | module_param_hw_array(iobase, int, ioport, NULL, 0); |
630 | MODULE_PARM_DESC(iobase, "baycom io base address" ); |
631 | module_param_hw_array(irq, int, irq, NULL, 0); |
632 | MODULE_PARM_DESC(irq, "baycom irq number" ); |
633 | |
634 | MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu" ); |
635 | MODULE_DESCRIPTION("Baycom ser12 half duplex amateur radio modem driver" ); |
636 | MODULE_LICENSE("GPL" ); |
637 | |
638 | /* --------------------------------------------------------------------- */ |
639 | |
640 | static int __init init_baycomserhdx(void) |
641 | { |
642 | int i, found = 0; |
643 | char set_hw = 1; |
644 | |
645 | printk(bc_drvinfo); |
646 | /* |
647 | * register net devices |
648 | */ |
649 | for (i = 0; i < NR_PORTS; i++) { |
650 | struct net_device *dev; |
651 | struct baycom_state *bc; |
652 | char ifname[IFNAMSIZ]; |
653 | |
654 | sprintf(buf: ifname, fmt: "bcsh%d" , i); |
655 | |
656 | if (!mode[i]) |
657 | set_hw = 0; |
658 | if (!set_hw) |
659 | iobase[i] = irq[i] = 0; |
660 | |
661 | dev = hdlcdrv_register(ops: &ser12_ops, |
662 | privsize: sizeof(struct baycom_state), |
663 | ifname, baseaddr: iobase[i], irq: irq[i], dma: 0); |
664 | if (IS_ERR(ptr: dev)) |
665 | break; |
666 | |
667 | bc = netdev_priv(dev); |
668 | if (set_hw && baycom_setmode(bc, modestr: mode[i])) |
669 | set_hw = 0; |
670 | found++; |
671 | baycom_device[i] = dev; |
672 | } |
673 | |
674 | if (!found) |
675 | return -ENXIO; |
676 | return 0; |
677 | } |
678 | |
679 | static void __exit cleanup_baycomserhdx(void) |
680 | { |
681 | int i; |
682 | |
683 | for(i = 0; i < NR_PORTS; i++) { |
684 | struct net_device *dev = baycom_device[i]; |
685 | |
686 | if (dev) |
687 | hdlcdrv_unregister(dev); |
688 | } |
689 | } |
690 | |
691 | module_init(init_baycomserhdx); |
692 | module_exit(cleanup_baycomserhdx); |
693 | |
694 | /* --------------------------------------------------------------------- */ |
695 | |
696 | #ifndef MODULE |
697 | |
698 | /* |
699 | * format: baycom_ser_hdx=io,irq,mode |
700 | * mode: ser12 hardware DCD |
701 | * ser12* software DCD |
702 | * ser12@ hardware/software DCD, i.e. no explicit DCD signal but hardware |
703 | * mutes audio input to the modem |
704 | * ser12+ hardware DCD, inverted signal at DCD pin |
705 | */ |
706 | |
707 | static int __init baycom_ser_hdx_setup(char *str) |
708 | { |
709 | static unsigned nr_dev; |
710 | int ints[3]; |
711 | |
712 | if (nr_dev >= NR_PORTS) |
713 | return 0; |
714 | str = get_options(str, nints: 3, ints); |
715 | if (ints[0] < 2) |
716 | return 0; |
717 | mode[nr_dev] = str; |
718 | iobase[nr_dev] = ints[1]; |
719 | irq[nr_dev] = ints[2]; |
720 | nr_dev++; |
721 | return 1; |
722 | } |
723 | |
724 | __setup("baycom_ser_hdx=" , baycom_ser_hdx_setup); |
725 | |
726 | #endif /* MODULE */ |
727 | /* --------------------------------------------------------------------- */ |
728 | |