1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* ELM327 based CAN interface driver (tty line discipline) |
3 | * |
4 | * This driver started as a derivative of linux/drivers/net/can/slcan.c |
5 | * and my thanks go to the original authors for their inspiration. |
6 | * |
7 | * can327.c Author : Max Staudt <max-linux@enpas.org> |
8 | * slcan.c Author : Oliver Hartkopp <socketcan@hartkopp.net> |
9 | * slip.c Authors : Laurence Culhane <loz@holmes.demon.co.uk> |
10 | * Fred N. van Kempen <waltje@uwalt.nl.mugnet.org> |
11 | */ |
12 | |
13 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
14 | |
15 | #include <linux/init.h> |
16 | #include <linux/module.h> |
17 | |
18 | #include <linux/bitops.h> |
19 | #include <linux/ctype.h> |
20 | #include <linux/errno.h> |
21 | #include <linux/kernel.h> |
22 | #include <linux/list.h> |
23 | #include <linux/lockdep.h> |
24 | #include <linux/netdevice.h> |
25 | #include <linux/skbuff.h> |
26 | #include <linux/spinlock.h> |
27 | #include <linux/string.h> |
28 | #include <linux/tty.h> |
29 | #include <linux/tty_ldisc.h> |
30 | #include <linux/workqueue.h> |
31 | |
32 | #include <uapi/linux/tty.h> |
33 | |
34 | #include <linux/can.h> |
35 | #include <linux/can/dev.h> |
36 | #include <linux/can/error.h> |
37 | #include <linux/can/rx-offload.h> |
38 | |
39 | #define CAN327_NAPI_WEIGHT 4 |
40 | |
41 | #define CAN327_SIZE_TXBUF 32 |
42 | #define CAN327_SIZE_RXBUF 1024 |
43 | |
44 | #define CAN327_CAN_CONFIG_SEND_SFF 0x8000 |
45 | #define CAN327_CAN_CONFIG_VARIABLE_DLC 0x4000 |
46 | #define CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF 0x2000 |
47 | #define CAN327_CAN_CONFIG_BAUDRATE_MULT_8_7 0x1000 |
48 | |
49 | #define CAN327_DUMMY_CHAR 'y' |
50 | #define CAN327_DUMMY_STRING "y" |
51 | #define CAN327_READY_CHAR '>' |
52 | |
53 | /* Bits in elm->cmds_todo */ |
54 | enum can327_tx_do { |
55 | CAN327_TX_DO_CAN_DATA = 0, |
56 | CAN327_TX_DO_CANID_11BIT, |
57 | CAN327_TX_DO_CANID_29BIT_LOW, |
58 | CAN327_TX_DO_CANID_29BIT_HIGH, |
59 | CAN327_TX_DO_CAN_CONFIG_PART2, |
60 | CAN327_TX_DO_CAN_CONFIG, |
61 | CAN327_TX_DO_RESPONSES, |
62 | CAN327_TX_DO_SILENT_MONITOR, |
63 | CAN327_TX_DO_INIT, |
64 | }; |
65 | |
66 | struct can327 { |
67 | /* This must be the first member when using alloc_candev() */ |
68 | struct can_priv can; |
69 | |
70 | struct can_rx_offload offload; |
71 | |
72 | /* TTY buffers */ |
73 | u8 txbuf[CAN327_SIZE_TXBUF]; |
74 | u8 rxbuf[CAN327_SIZE_RXBUF]; |
75 | |
76 | /* Per-channel lock */ |
77 | spinlock_t lock; |
78 | |
79 | /* TTY and netdev devices that we're bridging */ |
80 | struct tty_struct *tty; |
81 | struct net_device *dev; |
82 | |
83 | /* TTY buffer accounting */ |
84 | struct work_struct tx_work; /* Flushes TTY TX buffer */ |
85 | u8 *txhead; /* Next TX byte */ |
86 | size_t txleft; /* Bytes left to TX */ |
87 | int rxfill; /* Bytes already RX'd in buffer */ |
88 | |
89 | /* State machine */ |
90 | enum { |
91 | CAN327_STATE_NOTINIT = 0, |
92 | CAN327_STATE_GETDUMMYCHAR, |
93 | CAN327_STATE_GETPROMPT, |
94 | CAN327_STATE_RECEIVING, |
95 | } state; |
96 | |
97 | /* Things we have yet to send */ |
98 | char **next_init_cmd; |
99 | unsigned long cmds_todo; |
100 | |
101 | /* The CAN frame and config the ELM327 is sending/using, |
102 | * or will send/use after finishing all cmds_todo |
103 | */ |
104 | struct can_frame can_frame_to_send; |
105 | u16 can_config; |
106 | u8 can_bitrate_divisor; |
107 | |
108 | /* Parser state */ |
109 | bool drop_next_line; |
110 | |
111 | /* Stop the channel on UART side hardware failure, e.g. stray |
112 | * characters or neverending lines. This may be caused by bad |
113 | * UART wiring, a bad ELM327, a bad UART bridge... |
114 | * Once this is true, nothing will be sent to the TTY. |
115 | */ |
116 | bool uart_side_failure; |
117 | }; |
118 | |
119 | static inline void can327_uart_side_failure(struct can327 *elm); |
120 | |
121 | static void can327_send(struct can327 *elm, const void *buf, size_t len) |
122 | { |
123 | int written; |
124 | |
125 | lockdep_assert_held(&elm->lock); |
126 | |
127 | if (elm->uart_side_failure) |
128 | return; |
129 | |
130 | memcpy(elm->txbuf, buf, len); |
131 | |
132 | /* Order of next two lines is *very* important. |
133 | * When we are sending a little amount of data, |
134 | * the transfer may be completed inside the ops->write() |
135 | * routine, because it's running with interrupts enabled. |
136 | * In this case we *never* got WRITE_WAKEUP event, |
137 | * if we did not request it before write operation. |
138 | * 14 Oct 1994 Dmitry Gorodchanin. |
139 | */ |
140 | set_bit(TTY_DO_WRITE_WAKEUP, addr: &elm->tty->flags); |
141 | written = elm->tty->ops->write(elm->tty, elm->txbuf, len); |
142 | if (written < 0) { |
143 | netdev_err(dev: elm->dev, format: "Failed to write to tty %s.\n" , |
144 | elm->tty->name); |
145 | can327_uart_side_failure(elm); |
146 | return; |
147 | } |
148 | |
149 | elm->txleft = len - written; |
150 | elm->txhead = elm->txbuf + written; |
151 | } |
152 | |
153 | /* Take the ELM327 out of almost any state and back into command mode. |
154 | * We send CAN327_DUMMY_CHAR which will either abort any running |
155 | * operation, or be echoed back to us in case we're already in command |
156 | * mode. |
157 | */ |
158 | static void can327_kick_into_cmd_mode(struct can327 *elm) |
159 | { |
160 | lockdep_assert_held(&elm->lock); |
161 | |
162 | if (elm->state != CAN327_STATE_GETDUMMYCHAR && |
163 | elm->state != CAN327_STATE_GETPROMPT) { |
164 | can327_send(elm, CAN327_DUMMY_STRING, len: 1); |
165 | |
166 | elm->state = CAN327_STATE_GETDUMMYCHAR; |
167 | } |
168 | } |
169 | |
170 | /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */ |
171 | static void can327_send_frame(struct can327 *elm, struct can_frame *frame) |
172 | { |
173 | lockdep_assert_held(&elm->lock); |
174 | |
175 | /* Schedule any necessary changes in ELM327's CAN configuration */ |
176 | if (elm->can_frame_to_send.can_id != frame->can_id) { |
177 | /* Set the new CAN ID for transmission. */ |
178 | if ((frame->can_id ^ elm->can_frame_to_send.can_id) |
179 | & CAN_EFF_FLAG) { |
180 | elm->can_config = |
181 | (frame->can_id & CAN_EFF_FLAG ? 0 : CAN327_CAN_CONFIG_SEND_SFF) | |
182 | CAN327_CAN_CONFIG_VARIABLE_DLC | |
183 | CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF | |
184 | elm->can_bitrate_divisor; |
185 | |
186 | set_bit(nr: CAN327_TX_DO_CAN_CONFIG, addr: &elm->cmds_todo); |
187 | } |
188 | |
189 | if (frame->can_id & CAN_EFF_FLAG) { |
190 | clear_bit(nr: CAN327_TX_DO_CANID_11BIT, addr: &elm->cmds_todo); |
191 | set_bit(nr: CAN327_TX_DO_CANID_29BIT_LOW, addr: &elm->cmds_todo); |
192 | set_bit(nr: CAN327_TX_DO_CANID_29BIT_HIGH, addr: &elm->cmds_todo); |
193 | } else { |
194 | set_bit(nr: CAN327_TX_DO_CANID_11BIT, addr: &elm->cmds_todo); |
195 | clear_bit(nr: CAN327_TX_DO_CANID_29BIT_LOW, |
196 | addr: &elm->cmds_todo); |
197 | clear_bit(nr: CAN327_TX_DO_CANID_29BIT_HIGH, |
198 | addr: &elm->cmds_todo); |
199 | } |
200 | } |
201 | |
202 | /* Schedule the CAN frame itself. */ |
203 | elm->can_frame_to_send = *frame; |
204 | set_bit(nr: CAN327_TX_DO_CAN_DATA, addr: &elm->cmds_todo); |
205 | |
206 | can327_kick_into_cmd_mode(elm); |
207 | } |
208 | |
209 | /* ELM327 initialisation sequence. |
210 | * The line length is limited by the buffer in can327_handle_prompt(). |
211 | */ |
212 | static char *can327_init_script[] = { |
213 | "AT WS\r" , /* v1.0: Warm Start */ |
214 | "AT PP FF OFF\r" , /* v1.0: All Programmable Parameters Off */ |
215 | "AT M0\r" , /* v1.0: Memory Off */ |
216 | "AT AL\r" , /* v1.0: Allow Long messages */ |
217 | "AT BI\r" , /* v1.0: Bypass Initialisation */ |
218 | "AT CAF0\r" , /* v1.0: CAN Auto Formatting Off */ |
219 | "AT CFC0\r" , /* v1.0: CAN Flow Control Off */ |
220 | "AT CF 000\r" , /* v1.0: Reset CAN ID Filter */ |
221 | "AT CM 000\r" , /* v1.0: Reset CAN ID Mask */ |
222 | "AT E1\r" , /* v1.0: Echo On */ |
223 | "AT H1\r" , /* v1.0: Headers On */ |
224 | "AT L0\r" , /* v1.0: Linefeeds Off */ |
225 | "AT SH 7DF\r" , /* v1.0: Set CAN sending ID to 0x7df */ |
226 | "AT ST FF\r" , /* v1.0: Set maximum Timeout for response after TX */ |
227 | "AT AT0\r" , /* v1.2: Adaptive Timing Off */ |
228 | "AT D1\r" , /* v1.3: Print DLC On */ |
229 | "AT S1\r" , /* v1.3: Spaces On */ |
230 | "AT TP B\r" , /* v1.0: Try Protocol B */ |
231 | NULL |
232 | }; |
233 | |
234 | static void can327_init_device(struct can327 *elm) |
235 | { |
236 | lockdep_assert_held(&elm->lock); |
237 | |
238 | elm->state = CAN327_STATE_NOTINIT; |
239 | elm->can_frame_to_send.can_id = 0x7df; /* ELM327 HW default */ |
240 | elm->rxfill = 0; |
241 | elm->drop_next_line = 0; |
242 | |
243 | /* We can only set the bitrate as a fraction of 500000. |
244 | * The bitrates listed in can327_bitrate_const will |
245 | * limit the user to the right values. |
246 | */ |
247 | elm->can_bitrate_divisor = 500000 / elm->can.bittiming.bitrate; |
248 | elm->can_config = |
249 | CAN327_CAN_CONFIG_SEND_SFF | CAN327_CAN_CONFIG_VARIABLE_DLC | |
250 | CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF | elm->can_bitrate_divisor; |
251 | |
252 | /* Configure ELM327 and then start monitoring */ |
253 | elm->next_init_cmd = &can327_init_script[0]; |
254 | set_bit(nr: CAN327_TX_DO_INIT, addr: &elm->cmds_todo); |
255 | set_bit(nr: CAN327_TX_DO_SILENT_MONITOR, addr: &elm->cmds_todo); |
256 | set_bit(nr: CAN327_TX_DO_RESPONSES, addr: &elm->cmds_todo); |
257 | set_bit(nr: CAN327_TX_DO_CAN_CONFIG, addr: &elm->cmds_todo); |
258 | |
259 | can327_kick_into_cmd_mode(elm); |
260 | } |
261 | |
262 | static void can327_feed_frame_to_netdev(struct can327 *elm, struct sk_buff *skb) |
263 | { |
264 | lockdep_assert_held(&elm->lock); |
265 | |
266 | if (!netif_running(dev: elm->dev)) { |
267 | kfree_skb(skb); |
268 | return; |
269 | } |
270 | |
271 | /* Queue for NAPI pickup. |
272 | * rx-offload will update stats and LEDs for us. |
273 | */ |
274 | if (can_rx_offload_queue_tail(offload: &elm->offload, skb)) |
275 | elm->dev->stats.rx_fifo_errors++; |
276 | |
277 | /* Wake NAPI */ |
278 | can_rx_offload_irq_finish(offload: &elm->offload); |
279 | } |
280 | |
281 | /* Called when we're out of ideas and just want it all to end. */ |
282 | static inline void can327_uart_side_failure(struct can327 *elm) |
283 | { |
284 | struct can_frame *frame; |
285 | struct sk_buff *skb; |
286 | |
287 | lockdep_assert_held(&elm->lock); |
288 | |
289 | elm->uart_side_failure = true; |
290 | |
291 | clear_bit(TTY_DO_WRITE_WAKEUP, addr: &elm->tty->flags); |
292 | |
293 | elm->can.can_stats.bus_off++; |
294 | netif_stop_queue(dev: elm->dev); |
295 | elm->can.state = CAN_STATE_BUS_OFF; |
296 | can_bus_off(dev: elm->dev); |
297 | |
298 | netdev_err(dev: elm->dev, |
299 | format: "ELM327 misbehaved. Blocking further communication.\n" ); |
300 | |
301 | skb = alloc_can_err_skb(dev: elm->dev, cf: &frame); |
302 | if (!skb) |
303 | return; |
304 | |
305 | frame->can_id |= CAN_ERR_BUSOFF; |
306 | can327_feed_frame_to_netdev(elm, skb); |
307 | } |
308 | |
309 | /* Compares a byte buffer (non-NUL terminated) to the payload part of |
310 | * a string, and returns true iff the buffer (content *and* length) is |
311 | * exactly that string, without the terminating NUL byte. |
312 | * |
313 | * Example: If reference is "BUS ERROR", then this returns true iff nbytes == 9 |
314 | * and !memcmp(buf, "BUS ERROR", 9). |
315 | * |
316 | * The reason to use strings is so we can easily include them in the C |
317 | * code, and to avoid hardcoding lengths. |
318 | */ |
319 | static inline bool can327_rxbuf_cmp(const u8 *buf, size_t nbytes, |
320 | const char *reference) |
321 | { |
322 | size_t ref_len = strlen(reference); |
323 | |
324 | return (nbytes == ref_len) && !memcmp(p: buf, q: reference, size: ref_len); |
325 | } |
326 | |
327 | static void can327_parse_error(struct can327 *elm, size_t len) |
328 | { |
329 | struct can_frame *frame; |
330 | struct sk_buff *skb; |
331 | |
332 | lockdep_assert_held(&elm->lock); |
333 | |
334 | skb = alloc_can_err_skb(dev: elm->dev, cf: &frame); |
335 | if (!skb) |
336 | /* It's okay to return here: |
337 | * The outer parsing loop will drop this UART buffer. |
338 | */ |
339 | return; |
340 | |
341 | /* Filter possible error messages based on length of RX'd line */ |
342 | if (can327_rxbuf_cmp(buf: elm->rxbuf, nbytes: len, reference: "UNABLE TO CONNECT" )) { |
343 | netdev_err(dev: elm->dev, |
344 | format: "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n" ); |
345 | } else if (can327_rxbuf_cmp(buf: elm->rxbuf, nbytes: len, reference: "BUFFER FULL" )) { |
346 | /* This will only happen if the last data line was complete. |
347 | * Otherwise, can327_parse_frame() will heuristically |
348 | * emit this kind of error frame instead. |
349 | */ |
350 | frame->can_id |= CAN_ERR_CRTL; |
351 | frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; |
352 | } else if (can327_rxbuf_cmp(buf: elm->rxbuf, nbytes: len, reference: "BUS ERROR" )) { |
353 | frame->can_id |= CAN_ERR_BUSERROR; |
354 | } else if (can327_rxbuf_cmp(buf: elm->rxbuf, nbytes: len, reference: "CAN ERROR" )) { |
355 | frame->can_id |= CAN_ERR_PROT; |
356 | } else if (can327_rxbuf_cmp(buf: elm->rxbuf, nbytes: len, reference: "<RX ERROR" )) { |
357 | frame->can_id |= CAN_ERR_PROT; |
358 | } else if (can327_rxbuf_cmp(buf: elm->rxbuf, nbytes: len, reference: "BUS BUSY" )) { |
359 | frame->can_id |= CAN_ERR_PROT; |
360 | frame->data[2] = CAN_ERR_PROT_OVERLOAD; |
361 | } else if (can327_rxbuf_cmp(buf: elm->rxbuf, nbytes: len, reference: "FB ERROR" )) { |
362 | frame->can_id |= CAN_ERR_PROT; |
363 | frame->data[2] = CAN_ERR_PROT_TX; |
364 | } else if (len == 5 && !memcmp(p: elm->rxbuf, q: "ERR" , size: 3)) { |
365 | /* ERR is followed by two digits, hence line length 5 */ |
366 | netdev_err(dev: elm->dev, format: "ELM327 reported an ERR%c%c. Please power it off and on again.\n" , |
367 | elm->rxbuf[3], elm->rxbuf[4]); |
368 | frame->can_id |= CAN_ERR_CRTL; |
369 | } else { |
370 | /* Something else has happened. |
371 | * Maybe garbage on the UART line. |
372 | * Emit a generic error frame. |
373 | */ |
374 | } |
375 | |
376 | can327_feed_frame_to_netdev(elm, skb); |
377 | } |
378 | |
379 | /* Parse CAN frames coming as ASCII from ELM327. |
380 | * They can be of various formats: |
381 | * |
382 | * 29-bit ID (EFF): 12 34 56 78 D PL PL PL PL PL PL PL PL |
383 | * 11-bit ID (!EFF): 123 D PL PL PL PL PL PL PL PL |
384 | * |
385 | * where D = DLC, PL = payload byte |
386 | * |
387 | * Instead of a payload, RTR indicates a remote request. |
388 | * |
389 | * We will use the spaces and line length to guess the format. |
390 | */ |
391 | static int can327_parse_frame(struct can327 *elm, size_t len) |
392 | { |
393 | struct can_frame *frame; |
394 | struct sk_buff *skb; |
395 | int hexlen; |
396 | int datastart; |
397 | int i; |
398 | |
399 | lockdep_assert_held(&elm->lock); |
400 | |
401 | skb = alloc_can_skb(dev: elm->dev, cf: &frame); |
402 | if (!skb) |
403 | return -ENOMEM; |
404 | |
405 | /* Find first non-hex and non-space character: |
406 | * - In the simplest case, there is none. |
407 | * - For RTR frames, 'R' is the first non-hex character. |
408 | * - An error message may replace the end of the data line. |
409 | */ |
410 | for (hexlen = 0; hexlen <= len; hexlen++) { |
411 | if (hex_to_bin(ch: elm->rxbuf[hexlen]) < 0 && |
412 | elm->rxbuf[hexlen] != ' ') { |
413 | break; |
414 | } |
415 | } |
416 | |
417 | /* Sanity check whether the line is really a clean hexdump, |
418 | * or terminated by an error message, or contains garbage. |
419 | */ |
420 | if (hexlen < len && !isdigit(c: elm->rxbuf[hexlen]) && |
421 | !isupper(elm->rxbuf[hexlen]) && '<' != elm->rxbuf[hexlen] && |
422 | ' ' != elm->rxbuf[hexlen]) { |
423 | /* The line is likely garbled anyway, so bail. |
424 | * The main code will restart listening. |
425 | */ |
426 | kfree_skb(skb); |
427 | return -ENODATA; |
428 | } |
429 | |
430 | /* Use spaces in CAN ID to distinguish 29 or 11 bit address length. |
431 | * No out-of-bounds access: |
432 | * We use the fact that we can always read from elm->rxbuf. |
433 | */ |
434 | if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' && |
435 | elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' && |
436 | elm->rxbuf[13] == ' ') { |
437 | frame->can_id = CAN_EFF_FLAG; |
438 | datastart = 14; |
439 | } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') { |
440 | datastart = 6; |
441 | } else { |
442 | /* This is not a well-formatted data line. |
443 | * Assume it's an error message. |
444 | */ |
445 | kfree_skb(skb); |
446 | return -ENODATA; |
447 | } |
448 | |
449 | if (hexlen < datastart) { |
450 | /* The line is too short to be a valid frame hex dump. |
451 | * Something interrupted the hex dump or it is invalid. |
452 | */ |
453 | kfree_skb(skb); |
454 | return -ENODATA; |
455 | } |
456 | |
457 | /* From here on all chars up to buf[hexlen] are hex or spaces, |
458 | * at well-defined offsets. |
459 | */ |
460 | |
461 | /* Read CAN data length */ |
462 | frame->len = (hex_to_bin(ch: elm->rxbuf[datastart - 2]) << 0); |
463 | |
464 | /* Read CAN ID */ |
465 | if (frame->can_id & CAN_EFF_FLAG) { |
466 | frame->can_id |= (hex_to_bin(ch: elm->rxbuf[0]) << 28) | |
467 | (hex_to_bin(ch: elm->rxbuf[1]) << 24) | |
468 | (hex_to_bin(ch: elm->rxbuf[3]) << 20) | |
469 | (hex_to_bin(ch: elm->rxbuf[4]) << 16) | |
470 | (hex_to_bin(ch: elm->rxbuf[6]) << 12) | |
471 | (hex_to_bin(ch: elm->rxbuf[7]) << 8) | |
472 | (hex_to_bin(ch: elm->rxbuf[9]) << 4) | |
473 | (hex_to_bin(ch: elm->rxbuf[10]) << 0); |
474 | } else { |
475 | frame->can_id |= (hex_to_bin(ch: elm->rxbuf[0]) << 8) | |
476 | (hex_to_bin(ch: elm->rxbuf[1]) << 4) | |
477 | (hex_to_bin(ch: elm->rxbuf[2]) << 0); |
478 | } |
479 | |
480 | /* Check for RTR frame */ |
481 | if (elm->rxfill >= hexlen + 3 && |
482 | !memcmp(p: &elm->rxbuf[hexlen], q: "RTR" , size: 3)) { |
483 | frame->can_id |= CAN_RTR_FLAG; |
484 | } |
485 | |
486 | /* Is the line long enough to hold the advertised payload? |
487 | * Note: RTR frames have a DLC, but no actual payload. |
488 | */ |
489 | if (!(frame->can_id & CAN_RTR_FLAG) && |
490 | (hexlen < frame->len * 3 + datastart)) { |
491 | /* Incomplete frame. |
492 | * Probably the ELM327's RS232 TX buffer was full. |
493 | * Emit an error frame and exit. |
494 | */ |
495 | frame->can_id = CAN_ERR_FLAG | CAN_ERR_CRTL; |
496 | frame->len = CAN_ERR_DLC; |
497 | frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; |
498 | can327_feed_frame_to_netdev(elm, skb); |
499 | |
500 | /* Signal failure to parse. |
501 | * The line will be re-parsed as an error line, which will fail. |
502 | * However, this will correctly drop the state machine back into |
503 | * command mode. |
504 | */ |
505 | return -ENODATA; |
506 | } |
507 | |
508 | /* Parse the data nibbles. */ |
509 | for (i = 0; i < frame->len; i++) { |
510 | frame->data[i] = |
511 | (hex_to_bin(ch: elm->rxbuf[datastart + 3 * i]) << 4) | |
512 | (hex_to_bin(ch: elm->rxbuf[datastart + 3 * i + 1])); |
513 | } |
514 | |
515 | /* Feed the frame to the network layer. */ |
516 | can327_feed_frame_to_netdev(elm, skb); |
517 | |
518 | return 0; |
519 | } |
520 | |
521 | static void can327_parse_line(struct can327 *elm, size_t len) |
522 | { |
523 | lockdep_assert_held(&elm->lock); |
524 | |
525 | /* Skip empty lines */ |
526 | if (!len) |
527 | return; |
528 | |
529 | /* Skip echo lines */ |
530 | if (elm->drop_next_line) { |
531 | elm->drop_next_line = 0; |
532 | return; |
533 | } else if (!memcmp(p: elm->rxbuf, q: "AT" , size: 2)) { |
534 | return; |
535 | } |
536 | |
537 | /* Regular parsing */ |
538 | if (elm->state == CAN327_STATE_RECEIVING && |
539 | can327_parse_frame(elm, len)) { |
540 | /* Parse an error line. */ |
541 | can327_parse_error(elm, len); |
542 | |
543 | /* Start afresh. */ |
544 | can327_kick_into_cmd_mode(elm); |
545 | } |
546 | } |
547 | |
548 | static void can327_handle_prompt(struct can327 *elm) |
549 | { |
550 | struct can_frame *frame = &elm->can_frame_to_send; |
551 | /* Size this buffer for the largest ELM327 line we may generate, |
552 | * which is currently an 8 byte CAN frame's payload hexdump. |
553 | * Items in can327_init_script must fit here, too! |
554 | */ |
555 | char local_txbuf[sizeof("0102030405060708\r" )]; |
556 | |
557 | lockdep_assert_held(&elm->lock); |
558 | |
559 | if (!elm->cmds_todo) { |
560 | /* Enter CAN monitor mode */ |
561 | can327_send(elm, buf: "ATMA\r" , len: 5); |
562 | elm->state = CAN327_STATE_RECEIVING; |
563 | |
564 | /* We will be in the default state once this command is |
565 | * sent, so enable the TX packet queue. |
566 | */ |
567 | netif_wake_queue(dev: elm->dev); |
568 | |
569 | return; |
570 | } |
571 | |
572 | /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */ |
573 | if (test_bit(CAN327_TX_DO_INIT, &elm->cmds_todo)) { |
574 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), fmt: "%s" , |
575 | *elm->next_init_cmd); |
576 | |
577 | elm->next_init_cmd++; |
578 | if (!(*elm->next_init_cmd)) { |
579 | clear_bit(nr: CAN327_TX_DO_INIT, addr: &elm->cmds_todo); |
580 | /* Init finished. */ |
581 | } |
582 | |
583 | } else if (test_and_clear_bit(nr: CAN327_TX_DO_SILENT_MONITOR, addr: &elm->cmds_todo)) { |
584 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), |
585 | fmt: "ATCSM%i\r" , |
586 | !!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)); |
587 | |
588 | } else if (test_and_clear_bit(nr: CAN327_TX_DO_RESPONSES, addr: &elm->cmds_todo)) { |
589 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), |
590 | fmt: "ATR%i\r" , |
591 | !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)); |
592 | |
593 | } else if (test_and_clear_bit(nr: CAN327_TX_DO_CAN_CONFIG, addr: &elm->cmds_todo)) { |
594 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), |
595 | fmt: "ATPC\r" ); |
596 | set_bit(nr: CAN327_TX_DO_CAN_CONFIG_PART2, addr: &elm->cmds_todo); |
597 | |
598 | } else if (test_and_clear_bit(nr: CAN327_TX_DO_CAN_CONFIG_PART2, addr: &elm->cmds_todo)) { |
599 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), |
600 | fmt: "ATPB%04X\r" , |
601 | elm->can_config); |
602 | |
603 | } else if (test_and_clear_bit(nr: CAN327_TX_DO_CANID_29BIT_HIGH, addr: &elm->cmds_todo)) { |
604 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), |
605 | fmt: "ATCP%02X\r" , |
606 | (frame->can_id & CAN_EFF_MASK) >> 24); |
607 | |
608 | } else if (test_and_clear_bit(nr: CAN327_TX_DO_CANID_29BIT_LOW, addr: &elm->cmds_todo)) { |
609 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), |
610 | fmt: "ATSH%06X\r" , |
611 | frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1)); |
612 | |
613 | } else if (test_and_clear_bit(nr: CAN327_TX_DO_CANID_11BIT, addr: &elm->cmds_todo)) { |
614 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), |
615 | fmt: "ATSH%03X\r" , |
616 | frame->can_id & CAN_SFF_MASK); |
617 | |
618 | } else if (test_and_clear_bit(nr: CAN327_TX_DO_CAN_DATA, addr: &elm->cmds_todo)) { |
619 | if (frame->can_id & CAN_RTR_FLAG) { |
620 | /* Send an RTR frame. Their DLC is fixed. |
621 | * Some chips don't send them at all. |
622 | */ |
623 | snprintf(buf: local_txbuf, size: sizeof(local_txbuf), fmt: "ATRTR\r" ); |
624 | } else { |
625 | /* Send a regular CAN data frame */ |
626 | int i; |
627 | |
628 | for (i = 0; i < frame->len; i++) { |
629 | snprintf(buf: &local_txbuf[2 * i], |
630 | size: sizeof(local_txbuf), fmt: "%02X" , |
631 | frame->data[i]); |
632 | } |
633 | |
634 | snprintf(buf: &local_txbuf[2 * i], size: sizeof(local_txbuf), |
635 | fmt: "\r" ); |
636 | } |
637 | |
638 | elm->drop_next_line = 1; |
639 | elm->state = CAN327_STATE_RECEIVING; |
640 | |
641 | /* We will be in the default state once this command is |
642 | * sent, so enable the TX packet queue. |
643 | */ |
644 | netif_wake_queue(dev: elm->dev); |
645 | } |
646 | |
647 | can327_send(elm, buf: local_txbuf, strlen(local_txbuf)); |
648 | } |
649 | |
650 | static bool can327_is_ready_char(char c) |
651 | { |
652 | /* Bits 0xc0 are sometimes set (randomly), hence the mask. |
653 | * Probably bad hardware. |
654 | */ |
655 | return (c & 0x3f) == CAN327_READY_CHAR; |
656 | } |
657 | |
658 | static void can327_drop_bytes(struct can327 *elm, size_t i) |
659 | { |
660 | lockdep_assert_held(&elm->lock); |
661 | |
662 | memmove(&elm->rxbuf[0], &elm->rxbuf[i], CAN327_SIZE_RXBUF - i); |
663 | elm->rxfill -= i; |
664 | } |
665 | |
666 | static void can327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx) |
667 | { |
668 | size_t len, pos; |
669 | |
670 | lockdep_assert_held(&elm->lock); |
671 | |
672 | switch (elm->state) { |
673 | case CAN327_STATE_NOTINIT: |
674 | elm->rxfill = 0; |
675 | break; |
676 | |
677 | case CAN327_STATE_GETDUMMYCHAR: |
678 | /* Wait for 'y' or '>' */ |
679 | for (pos = 0; pos < elm->rxfill; pos++) { |
680 | if (elm->rxbuf[pos] == CAN327_DUMMY_CHAR) { |
681 | can327_send(elm, buf: "\r" , len: 1); |
682 | elm->state = CAN327_STATE_GETPROMPT; |
683 | pos++; |
684 | break; |
685 | } else if (can327_is_ready_char(c: elm->rxbuf[pos])) { |
686 | can327_send(elm, CAN327_DUMMY_STRING, len: 1); |
687 | pos++; |
688 | break; |
689 | } |
690 | } |
691 | |
692 | can327_drop_bytes(elm, i: pos); |
693 | break; |
694 | |
695 | case CAN327_STATE_GETPROMPT: |
696 | /* Wait for '>' */ |
697 | if (can327_is_ready_char(c: elm->rxbuf[elm->rxfill - 1])) |
698 | can327_handle_prompt(elm); |
699 | |
700 | elm->rxfill = 0; |
701 | break; |
702 | |
703 | case CAN327_STATE_RECEIVING: |
704 | /* Find <CR> delimiting feedback lines. */ |
705 | len = first_new_char_idx; |
706 | while (len < elm->rxfill && elm->rxbuf[len] != '\r') |
707 | len++; |
708 | |
709 | if (len == CAN327_SIZE_RXBUF) { |
710 | /* Assume the buffer ran full with garbage. |
711 | * Did we even connect at the right baud rate? |
712 | */ |
713 | netdev_err(dev: elm->dev, |
714 | format: "RX buffer overflow. Faulty ELM327 or UART?\n" ); |
715 | can327_uart_side_failure(elm); |
716 | } else if (len == elm->rxfill) { |
717 | if (can327_is_ready_char(c: elm->rxbuf[elm->rxfill - 1])) { |
718 | /* The ELM327's AT ST response timeout ran out, |
719 | * so we got a prompt. |
720 | * Clear RX buffer and restart listening. |
721 | */ |
722 | elm->rxfill = 0; |
723 | |
724 | can327_handle_prompt(elm); |
725 | } |
726 | |
727 | /* No <CR> found - we haven't received a full line yet. |
728 | * Wait for more data. |
729 | */ |
730 | } else { |
731 | /* We have a full line to parse. */ |
732 | can327_parse_line(elm, len); |
733 | |
734 | /* Remove parsed data from RX buffer. */ |
735 | can327_drop_bytes(elm, i: len + 1); |
736 | |
737 | /* More data to parse? */ |
738 | if (elm->rxfill) |
739 | can327_parse_rxbuf(elm, first_new_char_idx: 0); |
740 | } |
741 | } |
742 | } |
743 | |
744 | static int can327_netdev_open(struct net_device *dev) |
745 | { |
746 | struct can327 *elm = netdev_priv(dev); |
747 | int err; |
748 | |
749 | spin_lock_bh(lock: &elm->lock); |
750 | |
751 | if (!elm->tty) { |
752 | spin_unlock_bh(lock: &elm->lock); |
753 | return -ENODEV; |
754 | } |
755 | |
756 | if (elm->uart_side_failure) |
757 | netdev_warn(dev: elm->dev, |
758 | format: "Reopening netdev after a UART side fault has been detected.\n" ); |
759 | |
760 | /* Clear TTY buffers */ |
761 | elm->rxfill = 0; |
762 | elm->txleft = 0; |
763 | |
764 | /* open_candev() checks for elm->can.bittiming.bitrate != 0 */ |
765 | err = open_candev(dev); |
766 | if (err) { |
767 | spin_unlock_bh(lock: &elm->lock); |
768 | return err; |
769 | } |
770 | |
771 | can327_init_device(elm); |
772 | spin_unlock_bh(lock: &elm->lock); |
773 | |
774 | err = can_rx_offload_add_manual(dev, offload: &elm->offload, CAN327_NAPI_WEIGHT); |
775 | if (err) { |
776 | close_candev(dev); |
777 | return err; |
778 | } |
779 | |
780 | can_rx_offload_enable(offload: &elm->offload); |
781 | |
782 | elm->can.state = CAN_STATE_ERROR_ACTIVE; |
783 | netif_start_queue(dev); |
784 | |
785 | return 0; |
786 | } |
787 | |
788 | static int can327_netdev_close(struct net_device *dev) |
789 | { |
790 | struct can327 *elm = netdev_priv(dev); |
791 | |
792 | /* Interrupt whatever the ELM327 is doing right now */ |
793 | spin_lock_bh(lock: &elm->lock); |
794 | can327_send(elm, CAN327_DUMMY_STRING, len: 1); |
795 | spin_unlock_bh(lock: &elm->lock); |
796 | |
797 | netif_stop_queue(dev); |
798 | |
799 | /* We don't flush the UART TX queue here, as we want final stop |
800 | * commands (like the above dummy char) to be flushed out. |
801 | */ |
802 | |
803 | can_rx_offload_disable(offload: &elm->offload); |
804 | elm->can.state = CAN_STATE_STOPPED; |
805 | can_rx_offload_del(offload: &elm->offload); |
806 | close_candev(dev); |
807 | |
808 | return 0; |
809 | } |
810 | |
811 | /* Send a can_frame to a TTY. */ |
812 | static netdev_tx_t can327_netdev_start_xmit(struct sk_buff *skb, |
813 | struct net_device *dev) |
814 | { |
815 | struct can327 *elm = netdev_priv(dev); |
816 | struct can_frame *frame = (struct can_frame *)skb->data; |
817 | |
818 | if (can_dev_dropped_skb(dev, skb)) |
819 | return NETDEV_TX_OK; |
820 | |
821 | /* We shouldn't get here after a hardware fault: |
822 | * can_bus_off() calls netif_carrier_off() |
823 | */ |
824 | if (elm->uart_side_failure) { |
825 | WARN_ON_ONCE(elm->uart_side_failure); |
826 | goto out; |
827 | } |
828 | |
829 | netif_stop_queue(dev); |
830 | |
831 | /* BHs are already disabled, so no spin_lock_bh(). |
832 | * See Documentation/networking/netdevices.rst |
833 | */ |
834 | spin_lock(lock: &elm->lock); |
835 | can327_send_frame(elm, frame); |
836 | spin_unlock(lock: &elm->lock); |
837 | |
838 | dev->stats.tx_packets++; |
839 | dev->stats.tx_bytes += frame->can_id & CAN_RTR_FLAG ? 0 : frame->len; |
840 | |
841 | skb_tx_timestamp(skb); |
842 | |
843 | out: |
844 | kfree_skb(skb); |
845 | return NETDEV_TX_OK; |
846 | } |
847 | |
848 | static const struct net_device_ops can327_netdev_ops = { |
849 | .ndo_open = can327_netdev_open, |
850 | .ndo_stop = can327_netdev_close, |
851 | .ndo_start_xmit = can327_netdev_start_xmit, |
852 | .ndo_change_mtu = can_change_mtu, |
853 | }; |
854 | |
855 | static const struct ethtool_ops can327_ethtool_ops = { |
856 | .get_ts_info = ethtool_op_get_ts_info, |
857 | }; |
858 | |
859 | static bool can327_is_valid_rx_char(u8 c) |
860 | { |
861 | static const bool lut_char_is_valid['z'] = { |
862 | ['\r'] = true, |
863 | [' '] = true, |
864 | ['.'] = true, |
865 | ['0'] = true, true, true, true, true, |
866 | ['5'] = true, true, true, true, true, |
867 | ['<'] = true, |
868 | [CAN327_READY_CHAR] = true, |
869 | ['?'] = true, |
870 | ['A'] = true, true, true, true, true, true, true, |
871 | ['H'] = true, true, true, true, true, true, true, |
872 | ['O'] = true, true, true, true, true, true, true, |
873 | ['V'] = true, true, true, true, true, |
874 | ['a'] = true, |
875 | ['b'] = true, |
876 | ['v'] = true, |
877 | [CAN327_DUMMY_CHAR] = true, |
878 | }; |
879 | BUILD_BUG_ON(CAN327_DUMMY_CHAR >= 'z'); |
880 | |
881 | return (c < ARRAY_SIZE(lut_char_is_valid) && lut_char_is_valid[c]); |
882 | } |
883 | |
884 | /* Handle incoming ELM327 ASCII data. |
885 | * This will not be re-entered while running, but other ldisc |
886 | * functions may be called in parallel. |
887 | */ |
888 | static void can327_ldisc_rx(struct tty_struct *tty, const u8 *cp, |
889 | const u8 *fp, size_t count) |
890 | { |
891 | struct can327 *elm = tty->disc_data; |
892 | size_t first_new_char_idx; |
893 | |
894 | if (elm->uart_side_failure) |
895 | return; |
896 | |
897 | spin_lock_bh(lock: &elm->lock); |
898 | |
899 | /* Store old rxfill, so can327_parse_rxbuf() will have |
900 | * the option of skipping already checked characters. |
901 | */ |
902 | first_new_char_idx = elm->rxfill; |
903 | |
904 | while (count--) { |
905 | if (elm->rxfill >= CAN327_SIZE_RXBUF) { |
906 | netdev_err(dev: elm->dev, |
907 | format: "Receive buffer overflowed. Bad chip or wiring? count = %zu" , |
908 | count); |
909 | goto uart_failure; |
910 | } |
911 | if (fp && *fp++) { |
912 | netdev_err(dev: elm->dev, |
913 | format: "Error in received character stream. Check your wiring." ); |
914 | goto uart_failure; |
915 | } |
916 | |
917 | /* Ignore NUL characters, which the PIC microcontroller may |
918 | * inadvertently insert due to a known hardware bug. |
919 | * See ELM327 documentation, which refers to a Microchip PIC |
920 | * bug description. |
921 | */ |
922 | if (*cp) { |
923 | /* Check for stray characters on the UART line. |
924 | * Likely caused by bad hardware. |
925 | */ |
926 | if (!can327_is_valid_rx_char(c: *cp)) { |
927 | netdev_err(dev: elm->dev, |
928 | format: "Received illegal character %02x.\n" , |
929 | *cp); |
930 | goto uart_failure; |
931 | } |
932 | |
933 | elm->rxbuf[elm->rxfill++] = *cp; |
934 | } |
935 | |
936 | cp++; |
937 | } |
938 | |
939 | can327_parse_rxbuf(elm, first_new_char_idx); |
940 | spin_unlock_bh(lock: &elm->lock); |
941 | |
942 | return; |
943 | uart_failure: |
944 | can327_uart_side_failure(elm); |
945 | spin_unlock_bh(lock: &elm->lock); |
946 | } |
947 | |
948 | /* Write out remaining transmit buffer. |
949 | * Scheduled when TTY is writable. |
950 | */ |
951 | static void can327_ldisc_tx_worker(struct work_struct *work) |
952 | { |
953 | struct can327 *elm = container_of(work, struct can327, tx_work); |
954 | ssize_t written; |
955 | |
956 | if (elm->uart_side_failure) |
957 | return; |
958 | |
959 | spin_lock_bh(lock: &elm->lock); |
960 | |
961 | if (elm->txleft) { |
962 | written = elm->tty->ops->write(elm->tty, elm->txhead, |
963 | elm->txleft); |
964 | if (written < 0) { |
965 | netdev_err(dev: elm->dev, format: "Failed to write to tty %s.\n" , |
966 | elm->tty->name); |
967 | can327_uart_side_failure(elm); |
968 | |
969 | spin_unlock_bh(lock: &elm->lock); |
970 | return; |
971 | } |
972 | |
973 | elm->txleft -= written; |
974 | elm->txhead += written; |
975 | } |
976 | |
977 | if (!elm->txleft) |
978 | clear_bit(TTY_DO_WRITE_WAKEUP, addr: &elm->tty->flags); |
979 | |
980 | spin_unlock_bh(lock: &elm->lock); |
981 | } |
982 | |
983 | /* Called by the driver when there's room for more data. */ |
984 | static void can327_ldisc_tx_wakeup(struct tty_struct *tty) |
985 | { |
986 | struct can327 *elm = tty->disc_data; |
987 | |
988 | schedule_work(work: &elm->tx_work); |
989 | } |
990 | |
991 | /* ELM327 can only handle bitrates that are integer divisors of 500 kHz, |
992 | * or 7/8 of that. Divisors are 1 to 64. |
993 | * Currently we don't implement support for 7/8 rates. |
994 | */ |
995 | static const u32 can327_bitrate_const[] = { |
996 | 7812, 7936, 8064, 8196, 8333, 8474, 8620, 8771, |
997 | 8928, 9090, 9259, 9433, 9615, 9803, 10000, 10204, |
998 | 10416, 10638, 10869, 11111, 11363, 11627, 11904, 12195, |
999 | 12500, 12820, 13157, 13513, 13888, 14285, 14705, 15151, |
1000 | 15625, 16129, 16666, 17241, 17857, 18518, 19230, 20000, |
1001 | 20833, 21739, 22727, 23809, 25000, 26315, 27777, 29411, |
1002 | 31250, 33333, 35714, 38461, 41666, 45454, 50000, 55555, |
1003 | 62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000 |
1004 | }; |
1005 | |
1006 | static int can327_ldisc_open(struct tty_struct *tty) |
1007 | { |
1008 | struct net_device *dev; |
1009 | struct can327 *elm; |
1010 | int err; |
1011 | |
1012 | if (!capable(CAP_NET_ADMIN)) |
1013 | return -EPERM; |
1014 | |
1015 | if (!tty->ops->write) |
1016 | return -EOPNOTSUPP; |
1017 | |
1018 | dev = alloc_candev(sizeof(struct can327), 0); |
1019 | if (!dev) |
1020 | return -ENFILE; |
1021 | elm = netdev_priv(dev); |
1022 | |
1023 | /* Configure TTY interface */ |
1024 | tty->receive_room = 65536; /* We don't flow control */ |
1025 | spin_lock_init(&elm->lock); |
1026 | INIT_WORK(&elm->tx_work, can327_ldisc_tx_worker); |
1027 | |
1028 | /* Configure CAN metadata */ |
1029 | elm->can.bitrate_const = can327_bitrate_const; |
1030 | elm->can.bitrate_const_cnt = ARRAY_SIZE(can327_bitrate_const); |
1031 | elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY; |
1032 | |
1033 | /* Configure netdev interface */ |
1034 | elm->dev = dev; |
1035 | dev->netdev_ops = &can327_netdev_ops; |
1036 | dev->ethtool_ops = &can327_ethtool_ops; |
1037 | |
1038 | /* Mark ldisc channel as alive */ |
1039 | elm->tty = tty; |
1040 | tty->disc_data = elm; |
1041 | |
1042 | /* Let 'er rip */ |
1043 | err = register_candev(dev: elm->dev); |
1044 | if (err) { |
1045 | free_candev(dev: elm->dev); |
1046 | return err; |
1047 | } |
1048 | |
1049 | netdev_info(dev: elm->dev, format: "can327 on %s.\n" , tty->name); |
1050 | |
1051 | return 0; |
1052 | } |
1053 | |
1054 | /* Close down a can327 channel. |
1055 | * This means flushing out any pending queues, and then returning. |
1056 | * This call is serialized against other ldisc functions: |
1057 | * Once this is called, no other ldisc function of ours is entered. |
1058 | * |
1059 | * We also use this function for a hangup event. |
1060 | */ |
1061 | static void can327_ldisc_close(struct tty_struct *tty) |
1062 | { |
1063 | struct can327 *elm = tty->disc_data; |
1064 | |
1065 | /* unregister_netdev() calls .ndo_stop() so we don't have to. */ |
1066 | unregister_candev(dev: elm->dev); |
1067 | |
1068 | /* Give UART one final chance to flush. |
1069 | * No need to clear TTY_DO_WRITE_WAKEUP since .write_wakeup() is |
1070 | * serialised against .close() and will not be called once we return. |
1071 | */ |
1072 | flush_work(work: &elm->tx_work); |
1073 | |
1074 | /* Mark channel as dead */ |
1075 | spin_lock_bh(lock: &elm->lock); |
1076 | tty->disc_data = NULL; |
1077 | elm->tty = NULL; |
1078 | spin_unlock_bh(lock: &elm->lock); |
1079 | |
1080 | netdev_info(dev: elm->dev, format: "can327 off %s.\n" , tty->name); |
1081 | |
1082 | free_candev(dev: elm->dev); |
1083 | } |
1084 | |
1085 | static int can327_ldisc_ioctl(struct tty_struct *tty, unsigned int cmd, |
1086 | unsigned long arg) |
1087 | { |
1088 | struct can327 *elm = tty->disc_data; |
1089 | unsigned int tmp; |
1090 | |
1091 | switch (cmd) { |
1092 | case SIOCGIFNAME: |
1093 | tmp = strnlen(p: elm->dev->name, IFNAMSIZ - 1) + 1; |
1094 | if (copy_to_user(to: (void __user *)arg, from: elm->dev->name, n: tmp)) |
1095 | return -EFAULT; |
1096 | return 0; |
1097 | |
1098 | case SIOCSIFHWADDR: |
1099 | return -EINVAL; |
1100 | |
1101 | default: |
1102 | return tty_mode_ioctl(tty, cmd, arg); |
1103 | } |
1104 | } |
1105 | |
1106 | static struct tty_ldisc_ops can327_ldisc = { |
1107 | .owner = THIS_MODULE, |
1108 | .name = KBUILD_MODNAME, |
1109 | .num = N_CAN327, |
1110 | .receive_buf = can327_ldisc_rx, |
1111 | .write_wakeup = can327_ldisc_tx_wakeup, |
1112 | .open = can327_ldisc_open, |
1113 | .close = can327_ldisc_close, |
1114 | .ioctl = can327_ldisc_ioctl, |
1115 | }; |
1116 | |
1117 | static int __init can327_init(void) |
1118 | { |
1119 | int status; |
1120 | |
1121 | status = tty_register_ldisc(new_ldisc: &can327_ldisc); |
1122 | if (status) |
1123 | pr_err("Can't register line discipline\n" ); |
1124 | |
1125 | return status; |
1126 | } |
1127 | |
1128 | static void __exit can327_exit(void) |
1129 | { |
1130 | /* This will only be called when all channels have been closed by |
1131 | * userspace - tty_ldisc.c takes care of the module's refcount. |
1132 | */ |
1133 | tty_unregister_ldisc(ldisc: &can327_ldisc); |
1134 | } |
1135 | |
1136 | module_init(can327_init); |
1137 | module_exit(can327_exit); |
1138 | |
1139 | MODULE_ALIAS_LDISC(N_CAN327); |
1140 | MODULE_DESCRIPTION("ELM327 based CAN interface" ); |
1141 | MODULE_LICENSE("GPL" ); |
1142 | MODULE_AUTHOR("Max Staudt <max@enpas.org>" ); |
1143 | |