From: norly Date: Sat, 18 Jun 2022 00:26:02 +0000 (+0200) Subject: Rename elm327_* to can327_* X-Git-Url: https://git.enpas.org/?p=elmcan.git;a=commitdiff_plain;h=60fb3f509f29f1233bdf8c3e921875616375e340 Rename elm327_* to can327_* --- diff --git a/module/can327.c b/module/can327.c index 82dbc66..3572cfb 100644 --- a/module/can327.c +++ b/module/can327.c @@ -50,31 +50,31 @@ #define len can_dlc #endif -#define ELM327_NAPI_WEIGHT 4 +#define CAN327_NAPI_WEIGHT 4 -#define ELM327_SIZE_TXBUF 32 -#define ELM327_SIZE_RXBUF 1024 +#define CAN327_SIZE_TXBUF 32 +#define CAN327_SIZE_RXBUF 1024 -#define ELM327_CAN_CONFIG_SEND_SFF 0x8000 -#define ELM327_CAN_CONFIG_VARIABLE_DLC 0x4000 -#define ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF 0x2000 -#define ELM327_CAN_CONFIG_BAUDRATE_MULT_8_7 0x1000 +#define CAN327_CAN_CONFIG_SEND_SFF 0x8000 +#define CAN327_CAN_CONFIG_VARIABLE_DLC 0x4000 +#define CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF 0x2000 +#define CAN327_CAN_CONFIG_BAUDRATE_MULT_8_7 0x1000 -#define ELM327_DUMMY_CHAR 'y' -#define ELM327_DUMMY_STRING "y" -#define ELM327_READY_CHAR '>' +#define CAN327_DUMMY_CHAR 'y' +#define CAN327_DUMMY_STRING "y" +#define CAN327_READY_CHAR '>' /* Bits in elm->cmds_todo */ -enum elm327_tx_do { - ELM327_TX_DO_CAN_DATA = 0, - ELM327_TX_DO_CANID_11BIT, - ELM327_TX_DO_CANID_29BIT_LOW, - ELM327_TX_DO_CANID_29BIT_HIGH, - ELM327_TX_DO_CAN_CONFIG_PART2, - ELM327_TX_DO_CAN_CONFIG, - ELM327_TX_DO_RESPONSES, - ELM327_TX_DO_SILENT_MONITOR, - ELM327_TX_DO_INIT +enum can327_tx_do { + CAN327_TX_DO_CAN_DATA = 0, + CAN327_TX_DO_CANID_11BIT, + CAN327_TX_DO_CANID_29BIT_LOW, + CAN327_TX_DO_CANID_29BIT_HIGH, + CAN327_TX_DO_CAN_CONFIG_PART2, + CAN327_TX_DO_CAN_CONFIG, + CAN327_TX_DO_RESPONSES, + CAN327_TX_DO_SILENT_MONITOR, + CAN327_TX_DO_INIT }; struct can327 { @@ -84,8 +84,8 @@ struct can327 { struct can_rx_offload offload; /* TTY buffers */ - u8 txbuf[ELM327_SIZE_TXBUF]; - u8 rxbuf[ELM327_SIZE_RXBUF]; + u8 txbuf[CAN327_SIZE_TXBUF]; + u8 rxbuf[CAN327_SIZE_RXBUF]; /* Per-channel lock */ spinlock_t lock; @@ -102,10 +102,10 @@ struct can327 { /* State machine */ enum { - ELM327_STATE_NOTINIT = 0, - ELM327_STATE_GETDUMMYCHAR, - ELM327_STATE_GETPROMPT, - ELM327_STATE_RECEIVING, + CAN327_STATE_NOTINIT = 0, + CAN327_STATE_GETDUMMYCHAR, + CAN327_STATE_GETPROMPT, + CAN327_STATE_RECEIVING, } state; /* Things we have yet to send */ @@ -130,9 +130,9 @@ struct can327 { bool uart_side_failure; }; -static inline void elm327_uart_side_failure(struct can327 *elm); +static inline void can327_uart_side_failure(struct can327 *elm); -static void elm327_send(struct can327 *elm, const void *buf, size_t len) +static void can327_send(struct can327 *elm, const void *buf, size_t len) { int written; @@ -157,7 +157,7 @@ static void elm327_send(struct can327 *elm, const void *buf, size_t len) netdev_err(elm->dev, "Failed to write to tty %s.\n", elm->tty->name); - elm327_uart_side_failure(elm); + can327_uart_side_failure(elm); return; } @@ -166,24 +166,24 @@ static void elm327_send(struct can327 *elm, const void *buf, size_t len) } /* Take the ELM327 out of almost any state and back into command mode. - * We send ELM327_DUMMY_CHAR which will either abort any running + * We send CAN327_DUMMY_CHAR which will either abort any running * operation, or be echoed back to us in case we're already in command * mode. */ -static void elm327_kick_into_cmd_mode(struct can327 *elm) +static void can327_kick_into_cmd_mode(struct can327 *elm) { lockdep_assert_held(&elm->lock); - if (elm->state != ELM327_STATE_GETDUMMYCHAR && - elm->state != ELM327_STATE_GETPROMPT) { - elm327_send(elm, ELM327_DUMMY_STRING, 1); + if (elm->state != CAN327_STATE_GETDUMMYCHAR && + elm->state != CAN327_STATE_GETPROMPT) { + can327_send(elm, CAN327_DUMMY_STRING, 1); - elm->state = ELM327_STATE_GETDUMMYCHAR; + elm->state = CAN327_STATE_GETDUMMYCHAR; } } /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */ -static void elm327_send_frame(struct can327 *elm, struct can_frame *frame) +static void can327_send_frame(struct can327 *elm, struct can_frame *frame) { lockdep_assert_held(&elm->lock); @@ -194,36 +194,36 @@ static void elm327_send_frame(struct can327 *elm, struct can_frame *frame) & CAN_EFF_FLAG) { elm->can_config = (frame->can_id & CAN_EFF_FLAG ? 0 - : ELM327_CAN_CONFIG_SEND_SFF) - | ELM327_CAN_CONFIG_VARIABLE_DLC - | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF + : CAN327_CAN_CONFIG_SEND_SFF) + | CAN327_CAN_CONFIG_VARIABLE_DLC + | CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF | elm->can_bitrate_divisor; - set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo); + set_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo); } if (frame->can_id & CAN_EFF_FLAG) { - clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo); - set_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo); - set_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo); + clear_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo); + set_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo); + set_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo); } else { - set_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo); - clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo); - clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo); + set_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo); + clear_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo); + clear_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo); } } /* Schedule the CAN frame itself. */ elm->can_frame_to_send = *frame; - set_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo); + set_bit(CAN327_TX_DO_CAN_DATA, &elm->cmds_todo); - elm327_kick_into_cmd_mode(elm); + can327_kick_into_cmd_mode(elm); } /* ELM327 initialisation sequence. - * The line length is limited by the buffer in elm327_handle_prompt(). + * The line length is limited by the buffer in can327_handle_prompt(). */ -static char *elm327_init_script[] = { +static char *can327_init_script[] = { "AT WS\r", /* v1.0: Warm Start */ "AT PP FF OFF\r", /* v1.0: All Programmable Parameters Off */ "AT M0\r", /* v1.0: Memory Off */ @@ -245,11 +245,11 @@ static char *elm327_init_script[] = { NULL }; -static void elm327_init(struct can327 *elm) +static void can327_init_device(struct can327 *elm) { lockdep_assert_held(&elm->lock); - elm->state = ELM327_STATE_NOTINIT; + elm->state = CAN327_STATE_NOTINIT; elm->can_frame_to_send.can_id = 0x7df; /* ELM327 HW default */ elm->rxfill = 0; elm->drop_next_line = 0; @@ -259,22 +259,22 @@ static void elm327_init(struct can327 *elm) * limit the user to the right values. */ elm->can_bitrate_divisor = 500000 / elm->can.bittiming.bitrate; - elm->can_config = ELM327_CAN_CONFIG_SEND_SFF - | ELM327_CAN_CONFIG_VARIABLE_DLC - | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF + elm->can_config = CAN327_CAN_CONFIG_SEND_SFF + | CAN327_CAN_CONFIG_VARIABLE_DLC + | CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF | elm->can_bitrate_divisor; /* Configure ELM327 and then start monitoring */ - elm->next_init_cmd = &elm327_init_script[0]; - set_bit(ELM327_TX_DO_INIT, &elm->cmds_todo); - set_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo); - set_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo); - set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo); + elm->next_init_cmd = &can327_init_script[0]; + set_bit(CAN327_TX_DO_INIT, &elm->cmds_todo); + set_bit(CAN327_TX_DO_SILENT_MONITOR, &elm->cmds_todo); + set_bit(CAN327_TX_DO_RESPONSES, &elm->cmds_todo); + set_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo); - elm327_kick_into_cmd_mode(elm); + can327_kick_into_cmd_mode(elm); } -static void elm327_feed_frame_to_netdev(struct can327 *elm, +static void can327_feed_frame_to_netdev(struct can327 *elm, struct sk_buff *skb) { lockdep_assert_held(&elm->lock); @@ -295,7 +295,7 @@ static void elm327_feed_frame_to_netdev(struct can327 *elm, } /* Called when we're out of ideas and just want it all to end. */ -static inline void elm327_uart_side_failure(struct can327 *elm) +static inline void can327_uart_side_failure(struct can327 *elm) { struct can_frame *frame; struct sk_buff *skb; @@ -318,7 +318,7 @@ static inline void elm327_uart_side_failure(struct can327 *elm) return; frame->can_id |= CAN_ERR_BUSOFF; - elm327_feed_frame_to_netdev(elm, skb); + can327_feed_frame_to_netdev(elm, skb); } /* Compares a byte buffer (non-NUL terminated) to the payload part of a string, @@ -331,14 +331,14 @@ static inline void elm327_uart_side_failure(struct can327 *elm) * The reason to use strings is so we can easily include them in the C code, * and to avoid hardcoding lengths. */ -static inline bool elm327_rxbuf_cmp(const u8 *buf, size_t nbytes, const char *reference) +static inline bool can327_rxbuf_cmp(const u8 *buf, size_t nbytes, const char *reference) { size_t ref_len = strlen(reference); return (nbytes == ref_len) && !memcmp(buf, reference, ref_len); } -static void elm327_parse_error(struct can327 *elm, size_t len) +static void can327_parse_error(struct can327 *elm, size_t len) { struct can_frame *frame; struct sk_buff *skb; @@ -353,26 +353,26 @@ static void elm327_parse_error(struct can327 *elm, size_t len) return; /* Filter possible error messages based on length of RX'd line */ - if (elm327_rxbuf_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) { + if (can327_rxbuf_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) { netdev_err(elm->dev, "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n"); - } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "BUFFER FULL")) { + } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUFFER FULL")) { /* This will only happen if the last data line was complete. - * Otherwise, elm327_parse_frame() will heuristically + * Otherwise, can327_parse_frame() will heuristically * emit this kind of error frame instead. */ frame->can_id |= CAN_ERR_CRTL; frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; - } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "BUS ERROR")) { + } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUS ERROR")) { frame->can_id |= CAN_ERR_BUSERROR; - } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "CAN ERROR")) { + } else if (can327_rxbuf_cmp(elm->rxbuf, len, "CAN ERROR")) { frame->can_id |= CAN_ERR_PROT; - } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "rxbuf, len, "can_id |= CAN_ERR_PROT; - } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "BUS BUSY")) { + } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUS BUSY")) { frame->can_id |= CAN_ERR_PROT; frame->data[2] = CAN_ERR_PROT_OVERLOAD; - } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "FB ERROR")) { + } else if (can327_rxbuf_cmp(elm->rxbuf, len, "FB ERROR")) { frame->can_id |= CAN_ERR_PROT; frame->data[2] = CAN_ERR_PROT_TX; } else if (len == 5 && !memcmp(elm->rxbuf, "ERR", 3)) { @@ -387,7 +387,7 @@ static void elm327_parse_error(struct can327 *elm, size_t len) */ } - elm327_feed_frame_to_netdev(elm, skb); + can327_feed_frame_to_netdev(elm, skb); } /* Parse CAN frames coming as ASCII from ELM327. @@ -402,7 +402,7 @@ static void elm327_parse_error(struct can327 *elm, size_t len) * * We will use the spaces and line length to guess the format. */ -static int elm327_parse_frame(struct can327 *elm, size_t len) +static int can327_parse_frame(struct can327 *elm, size_t len) { struct can_frame *frame; struct sk_buff *skb; @@ -511,7 +511,7 @@ static int elm327_parse_frame(struct can327 *elm, size_t len) frame->can_id = CAN_ERR_FLAG | CAN_ERR_CRTL; frame->len = CAN_ERR_DLC; frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; - elm327_feed_frame_to_netdev(elm, skb); + can327_feed_frame_to_netdev(elm, skb); /* Signal failure to parse. * The line will be re-parsed as an error line, which will fail. @@ -529,12 +529,12 @@ static int elm327_parse_frame(struct can327 *elm, size_t len) } /* Feed the frame to the network layer. */ - elm327_feed_frame_to_netdev(elm, skb); + can327_feed_frame_to_netdev(elm, skb); return 0; } -static void elm327_parse_line(struct can327 *elm, size_t len) +static void can327_parse_line(struct can327 *elm, size_t len) { lockdep_assert_held(&elm->lock); @@ -551,22 +551,22 @@ static void elm327_parse_line(struct can327 *elm, size_t len) } /* Regular parsing */ - if (elm->state == ELM327_STATE_RECEIVING && - elm327_parse_frame(elm, len)) { + if (elm->state == CAN327_STATE_RECEIVING && + can327_parse_frame(elm, len)) { /* Parse an error line. */ - elm327_parse_error(elm, len); + can327_parse_error(elm, len); /* Start afresh. */ - elm327_kick_into_cmd_mode(elm); + can327_kick_into_cmd_mode(elm); } } -static void elm327_handle_prompt(struct can327 *elm) +static void can327_handle_prompt(struct can327 *elm) { struct can_frame *frame = &elm->can_frame_to_send; /* Size this buffer for the largest ELM327 line we may generate, * which is currently an 8 byte CAN frame's payload hexdump. - * Items in elm327_init_script must fit here, too! + * Items in can327_init_script must fit here, too! */ char local_txbuf[sizeof("0102030405060708\r")]; @@ -574,8 +574,8 @@ static void elm327_handle_prompt(struct can327 *elm) if (!elm->cmds_todo) { /* Enter CAN monitor mode */ - elm327_send(elm, "ATMA\r", 5); - elm->state = ELM327_STATE_RECEIVING; + can327_send(elm, "ATMA\r", 5); + elm->state = CAN327_STATE_RECEIVING; /* We will be in the default state once this command is * sent, so enable the TX packet queue. @@ -586,53 +586,53 @@ static void elm327_handle_prompt(struct can327 *elm) } /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */ - if (test_bit(ELM327_TX_DO_INIT, &elm->cmds_todo)) { + if (test_bit(CAN327_TX_DO_INIT, &elm->cmds_todo)) { snprintf(local_txbuf, sizeof(local_txbuf), "%s", *elm->next_init_cmd); elm->next_init_cmd++; if (!(*elm->next_init_cmd)) { - clear_bit(ELM327_TX_DO_INIT, &elm->cmds_todo); + clear_bit(CAN327_TX_DO_INIT, &elm->cmds_todo); /* Init finished. */ } - } else if (test_and_clear_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) { + } else if (test_and_clear_bit(CAN327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) { snprintf(local_txbuf, sizeof(local_txbuf), "ATCSM%i\r", !!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)); - } else if (test_and_clear_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo)) { + } else if (test_and_clear_bit(CAN327_TX_DO_RESPONSES, &elm->cmds_todo)) { snprintf(local_txbuf, sizeof(local_txbuf), "ATR%i\r", !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)); - } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) { + } else if (test_and_clear_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) { snprintf(local_txbuf, sizeof(local_txbuf), "ATPC\r"); - set_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo); + set_bit(CAN327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo); - } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) { + } else if (test_and_clear_bit(CAN327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) { snprintf(local_txbuf, sizeof(local_txbuf), "ATPB%04X\r", elm->can_config); - } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) { + } else if (test_and_clear_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) { snprintf(local_txbuf, sizeof(local_txbuf), "ATCP%02X\r", (frame->can_id & CAN_EFF_MASK) >> 24); - } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) { + } else if (test_and_clear_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) { snprintf(local_txbuf, sizeof(local_txbuf), "ATSH%06X\r", frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1)); - } else if (test_and_clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo)) { + } else if (test_and_clear_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo)) { snprintf(local_txbuf, sizeof(local_txbuf), "ATSH%03X\r", frame->can_id & CAN_SFF_MASK); - } else if (test_and_clear_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo)) { + } else if (test_and_clear_bit(CAN327_TX_DO_CAN_DATA, &elm->cmds_todo)) { if (frame->can_id & CAN_RTR_FLAG) { /* Send an RTR frame. Their DLC is fixed. * Some chips don't send them at all. @@ -654,7 +654,7 @@ static void elm327_handle_prompt(struct can327 *elm) } elm->drop_next_line = 1; - elm->state = ELM327_STATE_RECEIVING; + elm->state = CAN327_STATE_RECEIVING; /* We will be in the default state once this command is * sent, so enable the TX packet queue. @@ -662,84 +662,84 @@ static void elm327_handle_prompt(struct can327 *elm) netif_wake_queue(elm->dev); } - elm327_send(elm, local_txbuf, strlen(local_txbuf)); + can327_send(elm, local_txbuf, strlen(local_txbuf)); } -static bool elm327_is_ready_char(char c) +static bool can327_is_ready_char(char c) { /* Bits 0xc0 are sometimes set (randomly), hence the mask. * Probably bad hardware. */ - return (c & 0x3f) == ELM327_READY_CHAR; + return (c & 0x3f) == CAN327_READY_CHAR; } -static void elm327_drop_bytes(struct can327 *elm, size_t i) +static void can327_drop_bytes(struct can327 *elm, size_t i) { lockdep_assert_held(&elm->lock); - memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i); + memmove(&elm->rxbuf[0], &elm->rxbuf[i], CAN327_SIZE_RXBUF - i); elm->rxfill -= i; } -static void elm327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx) +static void can327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx) { size_t len, pos; lockdep_assert_held(&elm->lock); switch (elm->state) { - case ELM327_STATE_NOTINIT: + case CAN327_STATE_NOTINIT: elm->rxfill = 0; break; - case ELM327_STATE_GETDUMMYCHAR: + case CAN327_STATE_GETDUMMYCHAR: /* Wait for 'y' or '>' */ for (pos = 0; pos < elm->rxfill; pos++) { - if (elm->rxbuf[pos] == ELM327_DUMMY_CHAR) { - elm327_send(elm, "\r", 1); - elm->state = ELM327_STATE_GETPROMPT; + if (elm->rxbuf[pos] == CAN327_DUMMY_CHAR) { + can327_send(elm, "\r", 1); + elm->state = CAN327_STATE_GETPROMPT; pos++; break; - } else if (elm327_is_ready_char(elm->rxbuf[pos])) { - elm327_send(elm, ELM327_DUMMY_STRING, 1); + } else if (can327_is_ready_char(elm->rxbuf[pos])) { + can327_send(elm, CAN327_DUMMY_STRING, 1); pos++; break; } } - elm327_drop_bytes(elm, pos); + can327_drop_bytes(elm, pos); break; - case ELM327_STATE_GETPROMPT: + case CAN327_STATE_GETPROMPT: /* Wait for '>' */ - if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) - elm327_handle_prompt(elm); + if (can327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) + can327_handle_prompt(elm); elm->rxfill = 0; break; - case ELM327_STATE_RECEIVING: + case CAN327_STATE_RECEIVING: /* Find delimiting feedback lines. */ len = first_new_char_idx; while (len < elm->rxfill && elm->rxbuf[len] != '\r') len++; - if (len == ELM327_SIZE_RXBUF) { + if (len == CAN327_SIZE_RXBUF) { /* Assume the buffer ran full with garbage. * Did we even connect at the right baud rate? */ netdev_err(elm->dev, "RX buffer overflow. Faulty ELM327 or UART?\n"); - elm327_uart_side_failure(elm); + can327_uart_side_failure(elm); } else if (len == elm->rxfill) { - if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) { + if (can327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) { /* The ELM327's AT ST response timeout ran out, * so we got a prompt. * Clear RX buffer and restart listening. */ elm->rxfill = 0; - elm327_handle_prompt(elm); + can327_handle_prompt(elm); } /* No found - we haven't received a full line yet. @@ -747,14 +747,14 @@ static void elm327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx) */ } else { /* We have a full line to parse. */ - elm327_parse_line(elm, len); + can327_parse_line(elm, len); /* Remove parsed data from RX buffer. */ - elm327_drop_bytes(elm, len + 1); + can327_drop_bytes(elm, len + 1); /* More data to parse? */ if (elm->rxfill) - elm327_parse_rxbuf(elm, 0); + can327_parse_rxbuf(elm, 0); } } } @@ -808,14 +808,14 @@ static int can327_netdev_open(struct net_device *dev) return err; } - elm327_init(elm); + can327_init_device(elm); spin_unlock_bh(&elm->lock); #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0) elm->offload.mailbox_read = can327_mailbox_read; - err = can_rx_offload_add_fifo(dev, &elm->offload, ELM327_NAPI_WEIGHT); + err = can_rx_offload_add_fifo(dev, &elm->offload, CAN327_NAPI_WEIGHT); #else - err = can_rx_offload_add_manual(dev, &elm->offload, ELM327_NAPI_WEIGHT); + err = can_rx_offload_add_manual(dev, &elm->offload, CAN327_NAPI_WEIGHT); #endif if (err) { close_candev(dev); @@ -836,7 +836,7 @@ static int can327_netdev_close(struct net_device *dev) /* Interrupt whatever the ELM327 is doing right now */ spin_lock_bh(&elm->lock); - elm327_send(elm, ELM327_DUMMY_STRING, 1); + can327_send(elm, CAN327_DUMMY_STRING, 1); spin_unlock_bh(&elm->lock); netif_stop_queue(dev); @@ -883,7 +883,7 @@ static netdev_tx_t can327_netdev_start_xmit(struct sk_buff *skb, * See Documentation/networking/netdevices.txt */ spin_lock(&elm->lock); - elm327_send_frame(elm, frame); + can327_send_frame(elm, frame); spin_unlock(&elm->lock); dev->stats.tx_packets++; @@ -910,7 +910,7 @@ static bool can327_is_valid_rx_char(u8 c) ['0'] = true, true, true, true, true, ['5'] = true, true, true, true, true, ['<'] = true, - [ELM327_READY_CHAR] = true, + [CAN327_READY_CHAR] = true, ['?'] = true, ['A'] = true, true, true, true, true, true, true, ['H'] = true, true, true, true, true, true, true, @@ -919,9 +919,9 @@ static bool can327_is_valid_rx_char(u8 c) ['a'] = true, ['b'] = true, ['v'] = true, - [ELM327_DUMMY_CHAR] = true, + [CAN327_DUMMY_CHAR] = true, }; - BUILD_BUG_ON(ELM327_DUMMY_CHAR >= 'z'); + BUILD_BUG_ON(CAN327_DUMMY_CHAR >= 'z'); return (c < ARRAY_SIZE(lut_char_is_valid) && lut_char_is_valid[c]); @@ -947,16 +947,16 @@ static void can327_ldisc_rx(struct tty_struct *tty, spin_lock_bh(&elm->lock); - /* Store old rxfill, so elm327_parse_rxbuf() will have + /* Store old rxfill, so can327_parse_rxbuf() will have * the option of skipping already checked characters. */ first_new_char_idx = elm->rxfill; - while (count-- && elm->rxfill < ELM327_SIZE_RXBUF) { + while (count-- && elm->rxfill < CAN327_SIZE_RXBUF) { if (fp && *fp++) { netdev_err(elm->dev, "Error in received character stream. Check your wiring."); - elm327_uart_side_failure(elm); + can327_uart_side_failure(elm); spin_unlock_bh(&elm->lock); return; @@ -975,7 +975,7 @@ static void can327_ldisc_rx(struct tty_struct *tty, netdev_err(elm->dev, "Received illegal character %02x.\n", *cp); - elm327_uart_side_failure(elm); + can327_uart_side_failure(elm); spin_unlock_bh(&elm->lock); return; @@ -990,13 +990,13 @@ static void can327_ldisc_rx(struct tty_struct *tty, if (count >= 0) { netdev_err(elm->dev, "Receive buffer overflowed. Bad chip or wiring? count = %i", count); - elm327_uart_side_failure(elm); + can327_uart_side_failure(elm); spin_unlock_bh(&elm->lock); return; } - elm327_parse_rxbuf(elm, first_new_char_idx); + can327_parse_rxbuf(elm, first_new_char_idx); spin_unlock_bh(&elm->lock); } @@ -1019,7 +1019,7 @@ static void can327_ldisc_tx_worker(struct work_struct *work) netdev_err(elm->dev, "Failed to write to tty %s.\n", elm->tty->name); - elm327_uart_side_failure(elm); + can327_uart_side_failure(elm); spin_unlock_bh(&elm->lock); return;