Lines Matching defs:elm
53 /* Bits in elm->cmds_todo */
119 static inline void can327_uart_side_failure(struct can327 *elm);
121 static void can327_send(struct can327 *elm, const void *buf, size_t len)
125 lockdep_assert_held(&elm->lock);
127 if (elm->uart_side_failure)
130 memcpy(elm->txbuf, buf, len);
140 set_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
141 written = elm->tty->ops->write(elm->tty, elm->txbuf, len);
143 netdev_err(elm->dev, "Failed to write to tty %s.\n",
144 elm->tty->name);
145 can327_uart_side_failure(elm);
149 elm->txleft = len - written;
150 elm->txhead = elm->txbuf + written;
158 static void can327_kick_into_cmd_mode(struct can327 *elm)
160 lockdep_assert_held(&elm->lock);
162 if (elm->state != CAN327_STATE_GETDUMMYCHAR &&
163 elm->state != CAN327_STATE_GETPROMPT) {
164 can327_send(elm, CAN327_DUMMY_STRING, 1);
166 elm->state = CAN327_STATE_GETDUMMYCHAR;
171 static void can327_send_frame(struct can327 *elm, struct can_frame *frame)
173 lockdep_assert_held(&elm->lock);
176 if (elm->can_frame_to_send.can_id != frame->can_id) {
178 if ((frame->can_id ^ elm->can_frame_to_send.can_id)
180 elm->can_config =
184 elm->can_bitrate_divisor;
186 set_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
190 clear_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo);
191 set_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
192 set_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
194 set_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo);
196 &elm->cmds_todo);
198 &elm->cmds_todo);
203 elm->can_frame_to_send = *frame;
204 set_bit(CAN327_TX_DO_CAN_DATA, &elm->cmds_todo);
206 can327_kick_into_cmd_mode(elm);
234 static void can327_init_device(struct can327 *elm)
236 lockdep_assert_held(&elm->lock);
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;
247 elm->can_bitrate_divisor = 500000 / elm->can.bittiming.bitrate;
248 elm->can_config =
250 CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF | elm->can_bitrate_divisor;
253 elm->next_init_cmd = &can327_init_script[0];
254 set_bit(CAN327_TX_DO_INIT, &elm->cmds_todo);
255 set_bit(CAN327_TX_DO_SILENT_MONITOR, &elm->cmds_todo);
256 set_bit(CAN327_TX_DO_RESPONSES, &elm->cmds_todo);
257 set_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
259 can327_kick_into_cmd_mode(elm);
262 static void can327_feed_frame_to_netdev(struct can327 *elm, struct sk_buff *skb)
264 lockdep_assert_held(&elm->lock);
266 if (!netif_running(elm->dev)) {
274 if (can_rx_offload_queue_tail(&elm->offload, skb))
275 elm->dev->stats.rx_fifo_errors++;
278 can_rx_offload_irq_finish(&elm->offload);
282 static inline void can327_uart_side_failure(struct can327 *elm)
287 lockdep_assert_held(&elm->lock);
289 elm->uart_side_failure = true;
291 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
293 elm->can.can_stats.bus_off++;
294 netif_stop_queue(elm->dev);
295 elm->can.state = CAN_STATE_BUS_OFF;
296 can_bus_off(elm->dev);
298 netdev_err(elm->dev,
301 skb = alloc_can_err_skb(elm->dev, &frame);
306 can327_feed_frame_to_netdev(elm, skb);
327 static void can327_parse_error(struct can327 *elm, size_t len)
332 lockdep_assert_held(&elm->lock);
334 skb = alloc_can_err_skb(elm->dev, &frame);
342 if (can327_rxbuf_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) {
343 netdev_err(elm->dev,
345 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUFFER FULL")) {
352 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUS ERROR")) {
354 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "CAN ERROR")) {
356 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "<RX ERROR")) {
358 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUS BUSY")) {
361 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "FB ERROR")) {
364 } else if (len == 5 && !memcmp(elm->rxbuf, "ERR", 3)) {
366 netdev_err(elm->dev, "ELM327 reported an ERR%c%c. Please power it off and on again.\n",
367 elm->rxbuf[3], elm->rxbuf[4]);
376 can327_feed_frame_to_netdev(elm, skb);
391 static int can327_parse_frame(struct can327 *elm, size_t len)
399 lockdep_assert_held(&elm->lock);
401 skb = alloc_can_skb(elm->dev, &frame);
411 if (hex_to_bin(elm->rxbuf[hexlen]) < 0 &&
412 elm->rxbuf[hexlen] != ' ') {
420 if (hexlen < len && !isdigit(elm->rxbuf[hexlen]) &&
421 !isupper(elm->rxbuf[hexlen]) && '<' != elm->rxbuf[hexlen] &&
422 ' ' != elm->rxbuf[hexlen]) {
432 * We use the fact that we can always read from elm->rxbuf.
434 if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' &&
435 elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' &&
436 elm->rxbuf[13] == ' ') {
439 } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
462 frame->len = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0);
466 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 28) |
467 (hex_to_bin(elm->rxbuf[1]) << 24) |
468 (hex_to_bin(elm->rxbuf[3]) << 20) |
469 (hex_to_bin(elm->rxbuf[4]) << 16) |
470 (hex_to_bin(elm->rxbuf[6]) << 12) |
471 (hex_to_bin(elm->rxbuf[7]) << 8) |
472 (hex_to_bin(elm->rxbuf[9]) << 4) |
473 (hex_to_bin(elm->rxbuf[10]) << 0);
475 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 8) |
476 (hex_to_bin(elm->rxbuf[1]) << 4) |
477 (hex_to_bin(elm->rxbuf[2]) << 0);
481 if (elm->rxfill >= hexlen + 3 &&
482 !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
498 can327_feed_frame_to_netdev(elm, skb);
511 (hex_to_bin(elm->rxbuf[datastart + 3 * i]) << 4) |
512 (hex_to_bin(elm->rxbuf[datastart + 3 * i + 1]));
516 can327_feed_frame_to_netdev(elm, skb);
521 static void can327_parse_line(struct can327 *elm, size_t len)
523 lockdep_assert_held(&elm->lock);
530 if (elm->drop_next_line) {
531 elm->drop_next_line = 0;
533 } else if (!memcmp(elm->rxbuf, "AT", 2)) {
538 if (elm->state == CAN327_STATE_RECEIVING &&
539 can327_parse_frame(elm, len)) {
541 can327_parse_error(elm, len);
544 can327_kick_into_cmd_mode(elm);
548 static void can327_handle_prompt(struct can327 *elm)
550 struct can_frame *frame = &elm->can_frame_to_send;
557 lockdep_assert_held(&elm->lock);
559 if (!elm->cmds_todo) {
561 can327_send(elm, "ATMA\r", 5);
562 elm->state = CAN327_STATE_RECEIVING;
567 netif_wake_queue(elm->dev);
572 /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */
573 if (test_bit(CAN327_TX_DO_INIT, &elm->cmds_todo)) {
575 *elm->next_init_cmd);
577 elm->next_init_cmd++;
578 if (!(*elm->next_init_cmd)) {
579 clear_bit(CAN327_TX_DO_INIT, &elm->cmds_todo);
583 } else if (test_and_clear_bit(CAN327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) {
586 !!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
588 } else if (test_and_clear_bit(CAN327_TX_DO_RESPONSES, &elm->cmds_todo)) {
591 !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
593 } else if (test_and_clear_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) {
596 set_bit(CAN327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo);
598 } else if (test_and_clear_bit(CAN327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
601 elm->can_config);
603 } else if (test_and_clear_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
608 } else if (test_and_clear_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) {
613 } else if (test_and_clear_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo)) {
618 } else if (test_and_clear_bit(CAN327_TX_DO_CAN_DATA, &elm->cmds_todo)) {
638 elm->drop_next_line = 1;
639 elm->state = CAN327_STATE_RECEIVING;
644 netif_wake_queue(elm->dev);
647 can327_send(elm, local_txbuf, strlen(local_txbuf));
658 static void can327_drop_bytes(struct can327 *elm, size_t i)
660 lockdep_assert_held(&elm->lock);
662 memmove(&elm->rxbuf[0], &elm->rxbuf[i], CAN327_SIZE_RXBUF - i);
663 elm->rxfill -= i;
666 static void can327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx)
670 lockdep_assert_held(&elm->lock);
672 switch (elm->state) {
674 elm->rxfill = 0;
679 for (pos = 0; pos < elm->rxfill; pos++) {
680 if (elm->rxbuf[pos] == CAN327_DUMMY_CHAR) {
681 can327_send(elm, "\r", 1);
682 elm->state = CAN327_STATE_GETPROMPT;
685 } else if (can327_is_ready_char(elm->rxbuf[pos])) {
686 can327_send(elm, CAN327_DUMMY_STRING, 1);
692 can327_drop_bytes(elm, pos);
697 if (can327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
698 can327_handle_prompt(elm);
700 elm->rxfill = 0;
706 while (len < elm->rxfill && elm->rxbuf[len] != '\r')
713 netdev_err(elm->dev,
715 can327_uart_side_failure(elm);
716 } else if (len == elm->rxfill) {
717 if (can327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
722 elm->rxfill = 0;
724 can327_handle_prompt(elm);
732 can327_parse_line(elm, len);
735 can327_drop_bytes(elm, len + 1);
738 if (elm->rxfill)
739 can327_parse_rxbuf(elm, 0);
746 struct can327 *elm = netdev_priv(dev);
749 spin_lock_bh(&elm->lock);
751 if (!elm->tty) {
752 spin_unlock_bh(&elm->lock);
756 if (elm->uart_side_failure)
757 netdev_warn(elm->dev,
761 elm->rxfill = 0;
762 elm->txleft = 0;
764 /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
767 spin_unlock_bh(&elm->lock);
771 can327_init_device(elm);
772 spin_unlock_bh(&elm->lock);
774 err = can_rx_offload_add_manual(dev, &elm->offload, CAN327_NAPI_WEIGHT);
780 can_rx_offload_enable(&elm->offload);
782 elm->can.state = CAN_STATE_ERROR_ACTIVE;
790 struct can327 *elm = netdev_priv(dev);
793 spin_lock_bh(&elm->lock);
794 can327_send(elm, CAN327_DUMMY_STRING, 1);
795 spin_unlock_bh(&elm->lock);
803 can_rx_offload_disable(&elm->offload);
804 elm->can.state = CAN_STATE_STOPPED;
805 can_rx_offload_del(&elm->offload);
815 struct can327 *elm = netdev_priv(dev);
824 if (elm->uart_side_failure) {
825 WARN_ON_ONCE(elm->uart_side_failure);
834 spin_lock(&elm->lock);
835 can327_send_frame(elm, frame);
836 spin_unlock(&elm->lock);
891 struct can327 *elm = tty->disc_data;
894 if (elm->uart_side_failure)
897 spin_lock_bh(&elm->lock);
902 first_new_char_idx = elm->rxfill;
905 if (elm->rxfill >= CAN327_SIZE_RXBUF) {
906 netdev_err(elm->dev,
912 netdev_err(elm->dev,
927 netdev_err(elm->dev,
933 elm->rxbuf[elm->rxfill++] = *cp;
939 can327_parse_rxbuf(elm, first_new_char_idx);
940 spin_unlock_bh(&elm->lock);
944 can327_uart_side_failure(elm);
945 spin_unlock_bh(&elm->lock);
953 struct can327 *elm = container_of(work, struct can327, tx_work);
956 if (elm->uart_side_failure)
959 spin_lock_bh(&elm->lock);
961 if (elm->txleft) {
962 written = elm->tty->ops->write(elm->tty, elm->txhead,
963 elm->txleft);
965 netdev_err(elm->dev, "Failed to write to tty %s.\n",
966 elm->tty->name);
967 can327_uart_side_failure(elm);
969 spin_unlock_bh(&elm->lock);
973 elm->txleft -= written;
974 elm->txhead += written;
977 if (!elm->txleft)
978 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
980 spin_unlock_bh(&elm->lock);
986 struct can327 *elm = tty->disc_data;
988 schedule_work(&elm->tx_work);
1009 struct can327 *elm;
1021 elm = netdev_priv(dev);
1025 spin_lock_init(&elm->lock);
1026 INIT_WORK(&elm->tx_work, can327_ldisc_tx_worker);
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;
1034 elm->dev = dev;
1039 elm->tty = tty;
1040 tty->disc_data = elm;
1043 err = register_candev(elm->dev);
1045 free_candev(elm->dev);
1049 netdev_info(elm->dev, "can327 on %s.\n", tty->name);
1063 struct can327 *elm = tty->disc_data;
1066 unregister_candev(elm->dev);
1072 flush_work(&elm->tx_work);
1075 spin_lock_bh(&elm->lock);
1077 elm->tty = NULL;
1078 spin_unlock_bh(&elm->lock);
1080 netdev_info(elm->dev, "can327 off %s.\n", tty->name);
1082 free_candev(elm->dev);
1088 struct can327 *elm = tty->disc_data;
1093 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1094 if (copy_to_user((void __user *)arg, elm->dev->name, tmp))