History

can: kvaser_pciefd: Refactor code

Refactor code; - Format code - Rename variables and macros - Remove intermediate variables - Add/remove blank lines - Reduce scope of variables - Add helper functions

Jimmy Assarsson committed 3 years ago

Commit f4845741 parent f07008a1 file · +87 −134Browse files

Unified · Split

drivers/net/can/kvaser_pciefd.c+87−134
@@ -70,7 +70,7 @@ MODULE_DESCRIPTION("CAN driver for Kvaser CAN/PCIe devices"); · 69 unmodified lines
7070 #define KVASER_PCIEFD_KCAN_CMD_REG 0x400
7171 #define KVASER_PCIEFD_KCAN_IEN_REG 0x408
7272 #define KVASER_PCIEFD_KCAN_IRQ_REG 0x410
73−#define KVASER_PCIEFD_KCAN_TX_NPACKETS_REG 0x414
73+#define KVASER_PCIEFD_KCAN_TX_NR_PACKETS_REG 0x414
7474 #define KVASER_PCIEFD_KCAN_STAT_REG 0x418
7575 #define KVASER_PCIEFD_KCAN_MODE_REG 0x41c
7676 #define KVASER_PCIEFD_KCAN_BTRN_REG 0x420
@@ -124,6 +124,8 @@ MODULE_DESCRIPTION("CAN driver for Kvaser CAN/PCIe devices"); · 47 unmodified lines
124124
125125 /* Command sequence number */
126126 #define KVASER_PCIEFD_KCAN_CMD_SEQ_MASK GENMASK(23, 16)
127+/* Command bits */
128+#define KVASER_PCIEFD_KCAN_CMD_MASK GENMASK(5, 0)
127129 /* Abort, flush and reset */
128130 #define KVASER_PCIEFD_KCAN_CMD_AT BIT(1)
129131 /* Request status packet */
@@ -172,9 +174,9 @@ MODULE_DESCRIPTION("CAN driver for Kvaser CAN/PCIe devices"); · 42 unmodified lines
172174 /* Abort request */
173175 #define KVASER_PCIEFD_KCAN_STAT_AR BIT(7)
174176 /* Controller is bus off */
175−#define KVASER_PCIEFD_KCAN_STAT_BUS_OFF_MSK (KVASER_PCIEFD_KCAN_STAT_AR | \
176− KVASER_PCIEFD_KCAN_STAT_BOFF | KVASER_PCIEFD_KCAN_STAT_RMR | \
177− KVASER_PCIEFD_KCAN_STAT_IRM)
177+#define KVASER_PCIEFD_KCAN_STAT_BUS_OFF_MASK \
178+ (KVASER_PCIEFD_KCAN_STAT_AR | KVASER_PCIEFD_KCAN_STAT_BOFF | \
179+ KVASER_PCIEFD_KCAN_STAT_RMR | KVASER_PCIEFD_KCAN_STAT_IRM)
178180
179181 /* Classic CAN mode */
180182 #define KVASER_PCIEFD_KCAN_MODE_CCM BIT(31)
@@ -202,15 +204,15 @@ MODULE_DESCRIPTION("CAN driver for Kvaser CAN/PCIe devices"); · 21 unmodified lines
202204 #define KVASER_PCIEFD_KCAN_PWM_TRIGGER_MASK GENMASK(7, 0)
203205
204206 /* KCAN packet type IDs */
205−#define KVASER_PCIEFD_PACK_TYPE_DATA 0
206−#define KVASER_PCIEFD_PACK_TYPE_ACK 1
207−#define KVASER_PCIEFD_PACK_TYPE_TXRQ 2
208−#define KVASER_PCIEFD_PACK_TYPE_ERROR 3
209−#define KVASER_PCIEFD_PACK_TYPE_EFLUSH_ACK 4
210−#define KVASER_PCIEFD_PACK_TYPE_EFRAME_ACK 5
211−#define KVASER_PCIEFD_PACK_TYPE_ACK_DATA 6
212−#define KVASER_PCIEFD_PACK_TYPE_STATUS 8
213−#define KVASER_PCIEFD_PACK_TYPE_BUS_LOAD 9
207+#define KVASER_PCIEFD_PACK_TYPE_DATA 0x0
208+#define KVASER_PCIEFD_PACK_TYPE_ACK 0x1
209+#define KVASER_PCIEFD_PACK_TYPE_TXRQ 0x2
210+#define KVASER_PCIEFD_PACK_TYPE_ERROR 0x3
211+#define KVASER_PCIEFD_PACK_TYPE_EFLUSH_ACK 0x4
212+#define KVASER_PCIEFD_PACK_TYPE_EFRAME_ACK 0x5
213+#define KVASER_PCIEFD_PACK_TYPE_ACK_DATA 0x6
214+#define KVASER_PCIEFD_PACK_TYPE_STATUS 0x8
215+#define KVASER_PCIEFD_PACK_TYPE_BUS_LOAD 0x9
214216
215217 /* Common KCAN packet definitions, second word */
216218 #define KVASER_PCIEFD_PACKET_TYPE_MASK GENMASK(31, 28)
@@ -322,13 +324,21 @@ static struct pci_device_id kvaser_pciefd_id_table[] = { · 105 unmodified lines
322324 };
323325 MODULE_DEVICE_TABLE(pci, kvaser_pciefd_id_table);
324326
325−static void kvaser_pciefd_request_status(struct kvaser_pciefd_can *can)
327+static inline void kvaser_pciefd_send_kcan_cmd(struct kvaser_pciefd_can *can, u32 cmd)
326328 {
327− u32 cmd;
329+ iowrite32(FIELD_PREP(KVASER_PCIEFD_KCAN_CMD_MASK, cmd) |
330+ FIELD_PREP(KVASER_PCIEFD_KCAN_CMD_SEQ_MASK, ++can->cmd_seq),
331+ can->reg_base + KVASER_PCIEFD_KCAN_CMD_REG);
332+}
333+
334+static inline void kvaser_pciefd_request_status(struct kvaser_pciefd_can *can)
335+{
336+ kvaser_pciefd_send_kcan_cmd(can, KVASER_PCIEFD_KCAN_CMD_SRQ);
337+}
328338
329− cmd = KVASER_PCIEFD_KCAN_CMD_SRQ;
330− cmd |= FIELD_PREP(KVASER_PCIEFD_KCAN_CMD_SEQ_MASK, ++can->cmd_seq);
331− iowrite32(cmd, can->reg_base + KVASER_PCIEFD_KCAN_CMD_REG);
339+static inline void kvaser_pciefd_abort_flush_reset(struct kvaser_pciefd_can *can)
340+{
341+ kvaser_pciefd_send_kcan_cmd(can, KVASER_PCIEFD_KCAN_CMD_AT);
332342 }
333343
334344 static void kvaser_pciefd_enable_err_gen(struct kvaser_pciefd_can *can)
@@ -383,7 +393,6 @@ static void kvaser_pciefd_setup_controller(struct kvaser_pciefd_can *can) · 48 unmodified lines
383393 unsigned long irq;
384394
385395 spin_lock_irqsave(&can->lock, irq);
386−
387396 mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);
388397 if (can->can.ctrlmode & CAN_CTRLMODE_FD) {
389398 mode &= ~KVASER_PCIEFD_KCAN_MODE_CCM;
@@ -400,7 +409,6 @@ static void kvaser_pciefd_setup_controller(struct kvaser_pciefd_can *can) · 10 unmodified lines
400409 mode |= KVASER_PCIEFD_KCAN_MODE_LOM;
401410 else
402411 mode &= ~KVASER_PCIEFD_KCAN_MODE_LOM;
403−
404412 mode |= KVASER_PCIEFD_KCAN_MODE_EEN;
405413 mode |= KVASER_PCIEFD_KCAN_MODE_EPEN;
406414 /* Use ACK packet type */
@@ -417,18 +425,13 @@ static void kvaser_pciefd_start_controller_flush(struct kvaser_pciefd_can *can) · 10 unmodified lines
417425 unsigned long irq;
418426
419427 spin_lock_irqsave(&can->lock, irq);
420− iowrite32(-1, can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
428+ iowrite32(GENMASK(31, 0), can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
421429 iowrite32(KVASER_PCIEFD_KCAN_IRQ_ABD,
422430 can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
423−
424431 status = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_STAT_REG);
425432 if (status & KVASER_PCIEFD_KCAN_STAT_IDLE) {
426− u32 cmd;
427−
428433 /* If controller is already idle, run abort, flush and reset */
429− cmd = KVASER_PCIEFD_KCAN_CMD_AT;
430− cmd |= FIELD_PREP(KVASER_PCIEFD_KCAN_CMD_SEQ_MASK, ++can->cmd_seq);
431− iowrite32(cmd, can->reg_base + KVASER_PCIEFD_KCAN_CMD_REG);
434+ kvaser_pciefd_abort_flush_reset(can);
432435 } else if (!(status & KVASER_PCIEFD_KCAN_STAT_RMR)) {
433436 u32 mode;
434437
@@ -437,7 +440,6 @@ static void kvaser_pciefd_start_controller_flush(struct kvaser_pciefd_can *can) · 2 unmodified lines
437440 mode |= KVASER_PCIEFD_KCAN_MODE_RM;
438441 iowrite32(mode, can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);
439442 }
440−
441443 spin_unlock_irqrestore(&can->lock, irq);
442444 }
443445
@@ -447,7 +449,6 @@ static int kvaser_pciefd_bus_on(struct kvaser_pciefd_can *can) · 3 unmodified lines
447449 unsigned long irq;
448450
449451 del_timer(&can->bec_poll_timer);
450−
451452 if (!completion_done(&can->flush_comp))
452453 kvaser_pciefd_start_controller_flush(can);
453454
@@ -459,11 +460,9 @@ static int kvaser_pciefd_bus_on(struct kvaser_pciefd_can *can) · 5 unmodified lines
459460
460461 spin_lock_irqsave(&can->lock, irq);
461462 iowrite32(0, can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
462− iowrite32(-1, can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
463−
463+ iowrite32(GENMASK(31, 0), can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
464464 iowrite32(KVASER_PCIEFD_KCAN_IRQ_ABD,
465465 can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
466−
467466 mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);
468467 mode &= ~KVASER_PCIEFD_KCAN_MODE_RM;
469468 iowrite32(mode, can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);
@@ -476,11 +475,10 @@ static int kvaser_pciefd_bus_on(struct kvaser_pciefd_can *can) · 6 unmodified lines
476475 }
477476 /* Reset interrupt handling */
478477 iowrite32(0, can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
479− iowrite32(-1, can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
478+ iowrite32(GENMASK(31, 0), can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
480479
481480 kvaser_pciefd_set_tx_irq(can);
482481 kvaser_pciefd_setup_controller(can);
483−
484482 can->can.state = CAN_STATE_ERROR_ACTIVE;
485483 netif_wake_queue(can->can.dev);
486484 can->bec.txerr = 0;
@@ -499,7 +497,6 @@ static void kvaser_pciefd_pwm_stop(struct kvaser_pciefd_can *can) · 12 unmodified lines
499497 spin_lock_irqsave(&can->lock, irq);
500498 pwm_ctrl = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_PWM_REG);
501499 top = FIELD_GET(KVASER_PCIEFD_KCAN_PWM_TOP_MASK, pwm_ctrl);
502−
503500 /* Set duty cycle to zero */
504501 pwm_ctrl |= FIELD_PREP(KVASER_PCIEFD_KCAN_PWM_TRIGGER_MASK, top);
505502 iowrite32(pwm_ctrl, can->reg_base + KVASER_PCIEFD_KCAN_PWM_REG);
@@ -514,8 +511,7 @@ static void kvaser_pciefd_pwm_start(struct kvaser_pciefd_can *can) · 8 unmodified lines
514511
515512 kvaser_pciefd_pwm_stop(can);
516513 spin_lock_irqsave(&can->lock, irq);
517−
518− /* Set frequency to 500 KHz*/
514+ /* Set frequency to 500 KHz */
519515 top = can->kv_pcie->bus_freq / (2 * 500000) - 1;
520516
521517 pwm_ctrl = FIELD_PREP(KVASER_PCIEFD_KCAN_PWM_TRIGGER_MASK, top);
@@ -580,7 +576,6 @@ static int kvaser_pciefd_prepare_tx_packet(struct kvaser_pciefd_tx_packet *p, · 58 unmodified lines
580576 int seq = can->echo_idx;
581577
582578 memset(p, 0, sizeof(*p));
583−
584579 if (can->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
585580 p->header[1] |= KVASER_PCIEFD_TPACKET_SMS;
586581
@@ -621,16 +616,15 @@ static netdev_tx_t kvaser_pciefd_start_xmit(struct sk_buff *skb, · 34 unmodified lines
621616 struct kvaser_pciefd_can *can = netdev_priv(netdev);
622617 unsigned long irq_flags;
623618 struct kvaser_pciefd_tx_packet packet;
624− int nwords;
619+ int nr_words;
625620 u8 count;
626621
627622 if (can_dev_dropped_skb(netdev, skb))
628623 return NETDEV_TX_OK;
629624
630− nwords = kvaser_pciefd_prepare_tx_packet(&packet, can, skb);
625+ nr_words = kvaser_pciefd_prepare_tx_packet(&packet, can, skb);
631626
632627 spin_lock_irqsave(&can->echo_lock, irq_flags);
633−
634628 /* Prepare and save echo skb in internal slot */
635629 can_put_echo_skb(skb, netdev, can->echo_idx, 0);
636630
@@ -643,13 +637,13 @@ static netdev_tx_t kvaser_pciefd_start_xmit(struct sk_buff *skb, · 6 unmodified lines
643637 iowrite32(packet.header[1],
644638 can->reg_base + KVASER_PCIEFD_KCAN_FIFO_REG);
645639
646− if (nwords) {
647− u32 data_last = ((u32 *)packet.data)[nwords - 1];
640+ if (nr_words) {
641+ u32 data_last = ((u32 *)packet.data)[nr_words - 1];
648642
649643 /* Write data to fifo, except last word */
650644 iowrite32_rep(can->reg_base +
651645 KVASER_PCIEFD_KCAN_FIFO_REG, packet.data,
652− nwords - 1);
646+ nr_words - 1);
653647 /* Write last word to end of fifo */
654648 __raw_writel(data_last, can->reg_base +
655649 KVASER_PCIEFD_KCAN_FIFO_LAST_REG);
@@ -660,14 +654,13 @@ static netdev_tx_t kvaser_pciefd_start_xmit(struct sk_buff *skb, · 4 unmodified lines
660654 }
661655
662656 count = FIELD_GET(KVASER_PCIEFD_KCAN_TX_NR_PACKETS_CURRENT_MASK,
663− ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NPACKETS_REG));
657+ ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NR_PACKETS_REG));
664658 /* No room for a new message, stop the queue until at least one
665659 * successful transmit
666660 */
667661 if (count >= KVASER_PCIEFD_CAN_TX_MAX_COUNT ||
668662 can->can.echo_skb[can->echo_idx])
669663 netif_stop_queue(netdev);
670−
671664 spin_unlock_irqrestore(&can->echo_lock, irq_flags);
672665
673666 return NETDEV_TX_OK;
@@ -692,16 +685,13 @@ static int kvaser_pciefd_set_bittiming(struct kvaser_pciefd_can *can, bool data) · 18 unmodified lines
692685
693686 spin_lock_irqsave(&can->lock, irq_flags);
694687 mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);
695−
696688 /* Put the circuit in reset mode */
697689 iowrite32(mode | KVASER_PCIEFD_KCAN_MODE_RM,
698690 can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);
699691
700692 /* Can only set bittiming if in reset mode */
701693 ret = readl_poll_timeout(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG,
702− test, test & KVASER_PCIEFD_KCAN_MODE_RM,
703− 0, 10);
704−
694+ test, test & KVASER_PCIEFD_KCAN_MODE_RM, 0, 10);
705695 if (ret) {
706696 spin_unlock_irqrestore(&can->lock, irq_flags);
707697 return -EBUSY;
@@ -711,11 +701,10 @@ static int kvaser_pciefd_set_bittiming(struct kvaser_pciefd_can *can, bool data) · 3 unmodified lines
711701 iowrite32(btrn, can->reg_base + KVASER_PCIEFD_KCAN_BTRD_REG);
712702 else
713703 iowrite32(btrn, can->reg_base + KVASER_PCIEFD_KCAN_BTRN_REG);
714−
715704 /* Restore previous reset mode status */
716705 iowrite32(mode, can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);
717−
718706 spin_unlock_irqrestore(&can->lock, irq_flags);
707+
719708 return 0;
720709 }
721710
@@ -753,6 +742,7 @@ static int kvaser_pciefd_get_berr_counter(const struct net_device *ndev, · 31 unmodified lines
753742
754743 bec->rxerr = can->bec.rxerr;
755744 bec->txerr = can->bec.txerr;
745+
756746 return 0;
757747 }
758748
@@ -796,7 +786,6 @@ static int kvaser_pciefd_setup_can_ctrls(struct kvaser_pciefd *pcie) · 37 unmodified lines
796786 netdev->ethtool_ops = &kvaser_pciefd_ethtool_ops;
797787 can->reg_base = pcie->reg_base + KVASER_PCIEFD_KCAN0_BASE +
798788 i * KVASER_PCIEFD_KCAN_BASE_OFFSET;
799−
800789 can->kv_pcie = pcie;
801790 can->cmd_seq = 0;
802791 can->err_rep_cnt = 0;
@@ -805,15 +794,14 @@ static int kvaser_pciefd_setup_can_ctrls(struct kvaser_pciefd *pcie) · 2 unmodified lines
805794
806795 init_completion(&can->start_comp);
807796 init_completion(&can->flush_comp);
808− timer_setup(&can->bec_poll_timer, kvaser_pciefd_bec_poll_timer,
809− 0);
797+ timer_setup(&can->bec_poll_timer, kvaser_pciefd_bec_poll_timer, 0);
810798
811799 /* Disable Bus load reporting */
812800 iowrite32(0, can->reg_base + KVASER_PCIEFD_KCAN_BUS_LOAD_REG);
813801
814802 tx_nr_packets_max =
815803 FIELD_GET(KVASER_PCIEFD_KCAN_TX_NR_PACKETS_MAX_MASK,
816− ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NPACKETS_REG));
804+ ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NR_PACKETS_REG));
817805 if (tx_nr_packets_max < KVASER_PCIEFD_CAN_TX_MAX_COUNT) {
818806 dev_err(&pcie->pci->dev,
819807 "Max Tx count is smaller than expected\n");
@@ -827,16 +815,13 @@ static int kvaser_pciefd_setup_can_ctrls(struct kvaser_pciefd *pcie) · 7 unmodified lines
827815 can->echo_idx = 0;
828816 spin_lock_init(&can->echo_lock);
829817 spin_lock_init(&can->lock);
818+
830819 can->can.bittiming_const = &kvaser_pciefd_bittiming_const;
831820 can->can.data_bittiming_const = &kvaser_pciefd_bittiming_const;
832−
833821 can->can.do_set_bittiming = kvaser_pciefd_set_nominal_bittiming;
834− can->can.do_set_data_bittiming =
835− kvaser_pciefd_set_data_bittiming;
836−
822+ can->can.do_set_data_bittiming = kvaser_pciefd_set_data_bittiming;
837823 can->can.do_set_mode = kvaser_pciefd_set_mode;
838824 can->can.do_get_berr_counter = kvaser_pciefd_get_berr_counter;
839−
840825 can->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY |
841826 CAN_CTRLMODE_FD |
842827 CAN_CTRLMODE_FD_NON_ISO |
@@ -855,10 +840,9 @@ static int kvaser_pciefd_setup_can_ctrls(struct kvaser_pciefd *pcie) · 12 unmodified lines
855840 can->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT;
856841
857842 netdev->flags |= IFF_ECHO;
858−
859843 SET_NETDEV_DEV(netdev, &pcie->pci->dev);
860844
861− iowrite32(-1, can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
845+ iowrite32(GENMASK(31, 0), can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
862846 iowrite32(KVASER_PCIEFD_KCAN_IRQ_ABD,
863847 can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
864848
@@ -917,18 +901,16 @@ static int kvaser_pciefd_setup_dma(struct kvaser_pciefd *pcie) · 52 unmodified lines
917901 for (i = 0; i < KVASER_PCIEFD_DMA_COUNT; i++) {
918902 unsigned int offset = KVASER_PCIEFD_DMA_MAP_BASE + 8 * i;
919903
920− pcie->dma_data[i] =
921− dmam_alloc_coherent(&pcie->pci->dev,
922− KVASER_PCIEFD_DMA_SIZE,
923− &dma_addr[i],
924− GFP_KERNEL);
904+ pcie->dma_data[i] = dmam_alloc_coherent(&pcie->pci->dev,
905+ KVASER_PCIEFD_DMA_SIZE,
906+ &dma_addr[i],
907+ GFP_KERNEL);
925908
926909 if (!pcie->dma_data[i] || !dma_addr[i]) {
927910 dev_err(&pcie->pci->dev, "Rx dma_alloc(%u) failure\n",
928911 KVASER_PCIEFD_DMA_SIZE);
929912 return -ENOMEM;
930913 }
931−
932914 kvaser_pciefd_write_dma_map(pcie, dma_addr[i], offset);
933915 }
934916
@@ -936,7 +918,6 @@ static int kvaser_pciefd_setup_dma(struct kvaser_pciefd *pcie) · 1 unmodified line
936918 iowrite32(KVASER_PCIEFD_SRB_CMD_FOR | KVASER_PCIEFD_SRB_CMD_RDB0 |
937919 KVASER_PCIEFD_SRB_CMD_RDB1,
938920 pcie->reg_base + KVASER_PCIEFD_SRB_CMD_REG);
939−
940921 /* Empty Rx FIFO */
941922 srb_packet_count =
942923 FIELD_GET(KVASER_PCIEFD_SRB_RX_NR_PACKETS_MASK,
@@ -976,8 +957,7 @@ static int kvaser_pciefd_setup_board(struct kvaser_pciefd *pcie) · 33 unmodified lines
976957
977958 srb_status = ioread32(pcie->reg_base + KVASER_PCIEFD_SRB_STAT_REG);
978959 if (!(srb_status & KVASER_PCIEFD_SRB_STAT_DMA)) {
979− dev_err(&pcie->pci->dev,
980− "Hardware without DMA is not supported\n");
960+ dev_err(&pcie->pci->dev, "Hardware without DMA is not supported\n");
981961 return -ENODEV;
982962 }
983963
@@ -987,9 +967,9 @@ static int kvaser_pciefd_setup_board(struct kvaser_pciefd *pcie) · 3 unmodified lines
987967 pcie->freq_to_ticks_div = pcie->freq / 1000000;
988968 if (pcie->freq_to_ticks_div == 0)
989969 pcie->freq_to_ticks_div = 1;
990−
991970 /* Turn off all loopback functionality */
992971 iowrite32(0, pcie->reg_base + KVASER_PCIEFD_LOOP_REG);
972+
993973 return 0;
994974 }
995975
@@ -1000,7 +980,6 @@ static int kvaser_pciefd_handle_data_packet(struct kvaser_pciefd *pcie, · 4 unmodified lines
1000980 struct sk_buff *skb;
1001981 struct canfd_frame *cf;
1002982 struct can_priv *priv;
1003− struct net_device_stats *stats;
1004983 u8 ch_id = FIELD_GET(KVASER_PCIEFD_PACKET_CHID_MASK, p->header[1]);
1005984 u8 dlc;
1006985
@@ -1008,26 +987,24 @@ static int kvaser_pciefd_handle_data_packet(struct kvaser_pciefd *pcie, · 1 unmodified line
1008987 return -EIO;
1009988
1010989 priv = &pcie->can[ch_id]->can;
1011− stats = &priv->dev->stats;
1012990 dlc = FIELD_GET(KVASER_PCIEFD_RPACKET_DLC_MASK, p->header[1]);
1013991
1014992 if (p->header[1] & KVASER_PCIEFD_RPACKET_FDF) {
1015993 skb = alloc_canfd_skb(priv->dev, &cf);
1016994 if (!skb) {
1017− stats->rx_dropped++;
995+ priv->dev->stats.rx_dropped++;
1018996 return -ENOMEM;
1019997 }
1020998
1021999 cf->len = can_fd_dlc2len(dlc);
10221000 if (p->header[1] & KVASER_PCIEFD_RPACKET_BRS)
10231001 cf->flags |= CANFD_BRS;
1024−
10251002 if (p->header[1] & KVASER_PCIEFD_RPACKET_ESI)
10261003 cf->flags |= CANFD_ESI;
10271004 } else {
10281005 skb = alloc_can_skb(priv->dev, (struct can_frame **)&cf);
10291006 if (!skb) {
1030− stats->rx_dropped++;
1007+ priv->dev->stats.rx_dropped++;
10311008 return -ENOMEM;
10321009 }
10331010 can_frame_set_cc_len((struct can_frame *)cf, dlc, priv->ctrlmode);
@@ -1041,10 +1018,9 @@ static int kvaser_pciefd_handle_data_packet(struct kvaser_pciefd *pcie, · 7 unmodified lines
10411018 cf->can_id |= CAN_RTR_FLAG;
10421019 } else {
10431020 memcpy(cf->data, data, cf->len);
1044−
1045− stats->rx_bytes += cf->len;
1021+ priv->dev->stats.rx_bytes += cf->len;
10461022 }
1047− stats->rx_packets++;
1023+ priv->dev->stats.rx_packets++;
10481024 kvaser_pciefd_set_skb_timestamp(pcie, skb, p->timestamp);
10491025
10501026 return netif_rx(skb);
@@ -1065,7 +1041,6 @@ static void kvaser_pciefd_change_state(struct kvaser_pciefd_can *can, · 14 unmodified lines
10651041 spin_lock_irqsave(&can->lock, irq_flags);
10661042 netif_stop_queue(can->can.dev);
10671043 spin_unlock_irqrestore(&can->lock, irq_flags);
1068−
10691044 /* Prevent CAN controller from auto recover from bus off */
10701045 if (!can->can.restart_ms) {
10711046 kvaser_pciefd_start_controller_flush(can);
@@ -1083,7 +1058,7 @@ static void kvaser_pciefd_packet_to_state(struct kvaser_pciefd_rx_packet *p, · 11 unmodified lines
10831058 if (p->header[0] & KVASER_PCIEFD_SPACK_BOFF ||
10841059 p->header[0] & KVASER_PCIEFD_SPACK_IRM)
10851060 *new_state = CAN_STATE_BUS_OFF;
1086− else if (bec->txerr >= 255 || bec->rxerr >= 255)
1061+ else if (bec->txerr >= 255 || bec->rxerr >= 255)
10871062 *new_state = CAN_STATE_BUS_OFF;
10881063 else if (p->header[1] & KVASER_PCIEFD_SPACK_EPLR)
10891064 *new_state = CAN_STATE_ERROR_PASSIVE;
@@ -1108,22 +1083,16 @@ static int kvaser_pciefd_rx_error_frame(struct kvaser_pciefd_can *can, · 18 unmodified lines
11081083 struct net_device *ndev = can->can.dev;
11091084 struct sk_buff *skb;
11101085 struct can_frame *cf = NULL;
1111− struct net_device_stats *stats = &ndev->stats;
11121086
11131087 old_state = can->can.state;
11141088
11151089 bec.txerr = FIELD_GET(KVASER_PCIEFD_SPACK_TXERR_MASK, p->header[0]);
11161090 bec.rxerr = FIELD_GET(KVASER_PCIEFD_SPACK_RXERR_MASK, p->header[0]);
11171091
1118− kvaser_pciefd_packet_to_state(p, &bec, &new_state, &tx_state,
1119− &rx_state);
1120−
1092+ kvaser_pciefd_packet_to_state(p, &bec, &new_state, &tx_state, &rx_state);
11211093 skb = alloc_can_err_skb(ndev, &cf);
1122−
11231094 if (new_state != old_state) {
1124− kvaser_pciefd_change_state(can, cf, new_state, tx_state,
1125− rx_state);
1126−
1095+ kvaser_pciefd_change_state(can, cf, new_state, tx_state, rx_state);
11271096 if (old_state == CAN_STATE_BUS_OFF &&
11281097 new_state == CAN_STATE_ERROR_ACTIVE &&
11291098 can->can.restart_ms) {
@@ -1136,25 +1105,25 @@ static int kvaser_pciefd_rx_error_frame(struct kvaser_pciefd_can *can, · 6 unmodified lines
11361105 can->err_rep_cnt++;
11371106 can->can.can_stats.bus_error++;
11381107 if (p->header[1] & KVASER_PCIEFD_EPACK_DIR_TX)
1139− stats->tx_errors++;
1108+ ndev->stats.tx_errors++;
11401109 else
1141− stats->rx_errors++;
1110+ ndev->stats.rx_errors++;
11421111
11431112 can->bec.txerr = bec.txerr;
11441113 can->bec.rxerr = bec.rxerr;
11451114
11461115 if (!skb) {
1147− stats->rx_dropped++;
1116+ ndev->stats.rx_dropped++;
11481117 return -ENOMEM;
11491118 }
11501119
11511120 kvaser_pciefd_set_skb_timestamp(can->kv_pcie, skb, p->timestamp);
11521121 cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_CNT;
1153−
11541122 cf->data[6] = bec.txerr;
11551123 cf->data[7] = bec.rxerr;
11561124
11571125 netif_rx(skb);
1126+
11581127 return 0;
11591128 }
11601129
@@ -1168,13 +1137,13 @@ static int kvaser_pciefd_handle_error_packet(struct kvaser_pciefd *pcie, · 7 unmodified lines
11681137 return -EIO;
11691138
11701139 can = pcie->can[ch_id];
1171−
11721140 kvaser_pciefd_rx_error_frame(can, p);
11731141 if (can->err_rep_cnt >= KVASER_PCIEFD_MAX_ERR_REP)
11741142 /* Do not report more errors, until bec_poll_timer expires */
11751143 kvaser_pciefd_disable_err_gen(can);
11761144 /* Start polling the error counters */
11771145 mod_timer(&can->bec_poll_timer, KVASER_PCIEFD_BEC_POLL_FREQ);
1146+
11781147 return 0;
11791148 }
11801149
@@ -1189,9 +1158,7 @@ static int kvaser_pciefd_handle_status_resp(struct kvaser_pciefd_can *can, · 8 unmodified lines
11891158 bec.txerr = FIELD_GET(KVASER_PCIEFD_SPACK_TXERR_MASK, p->header[0]);
11901159 bec.rxerr = FIELD_GET(KVASER_PCIEFD_SPACK_RXERR_MASK, p->header[0]);
11911160
1192− kvaser_pciefd_packet_to_state(p, &bec, &new_state, &tx_state,
1193− &rx_state);
1194−
1161+ kvaser_pciefd_packet_to_state(p, &bec, &new_state, &tx_state, &rx_state);
11951162 if (new_state != old_state) {
11961163 struct net_device *ndev = can->can.dev;
11971164 struct sk_buff *skb;
@@ -1199,15 +1166,11 @@ static int kvaser_pciefd_handle_status_resp(struct kvaser_pciefd_can *can, · 1 unmodified line
11991166
12001167 skb = alloc_can_err_skb(ndev, &cf);
12011168 if (!skb) {
1202− struct net_device_stats *stats = &ndev->stats;
1203−
1204− stats->rx_dropped++;
1169+ ndev->stats.rx_dropped++;
12051170 return -ENOMEM;
12061171 }
12071172
1208− kvaser_pciefd_change_state(can, cf, new_state, tx_state,
1209− rx_state);
1210−
1173+ kvaser_pciefd_change_state(can, cf, new_state, tx_state, rx_state);
12111174 if (old_state == CAN_STATE_BUS_OFF &&
12121175 new_state == CAN_STATE_ERROR_ACTIVE &&
12131176 can->can.restart_ms) {
@@ -1253,21 +1216,18 @@ static int kvaser_pciefd_handle_status_packet(struct kvaser_pciefd *pcie, · 39 unmodified lines
12531216 p->header[1] & KVASER_PCIEFD_SPACK_AUTO &&
12541217 cmdseq == FIELD_GET(KVASER_PCIEFD_PACKET_SEQ_MASK, p->header[1]) &&
12551218 status & KVASER_PCIEFD_KCAN_STAT_IDLE) {
1256− u32 cmd;
1257−
12581219 iowrite32(KVASER_PCIEFD_KCAN_IRQ_ABD,
12591220 can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);
1260− cmd = KVASER_PCIEFD_KCAN_CMD_AT;
1261− cmd |= FIELD_PREP(KVASER_PCIEFD_KCAN_CMD_SEQ_MASK, ++can->cmd_seq);
1262− iowrite32(cmd, can->reg_base + KVASER_PCIEFD_KCAN_CMD_REG);
1221+ kvaser_pciefd_abort_flush_reset(can);
12631222 } else if (p->header[0] & KVASER_PCIEFD_SPACK_IDET &&
12641223 p->header[0] & KVASER_PCIEFD_SPACK_IRM &&
12651224 cmdseq == FIELD_GET(KVASER_PCIEFD_PACKET_SEQ_MASK, p->header[1]) &&
12661225 status & KVASER_PCIEFD_KCAN_STAT_IDLE) {
12671226 /* Reset detected, send end of flush if no packet are in FIFO */
1268− u8 count = FIELD_GET(KVASER_PCIEFD_KCAN_TX_NR_PACKETS_CURRENT_MASK,
1269− ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NPACKETS_REG));
1227+ u8 count;
12701228
1229+ count = FIELD_GET(KVASER_PCIEFD_KCAN_TX_NR_PACKETS_CURRENT_MASK,
1230+ ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NR_PACKETS_REG));
12711231 if (!count)
12721232 iowrite32(FIELD_PREP(KVASER_PCIEFD_KCAN_CTRL_TYPE_MASK,
12731233 KVASER_PCIEFD_KCAN_CTRL_TYPE_EFLUSH),
@@ -1278,11 +1238,10 @@ static int kvaser_pciefd_handle_status_packet(struct kvaser_pciefd *pcie, · 4 unmodified lines
12781238 kvaser_pciefd_handle_status_resp(can, p);
12791239 if (can->can.state != CAN_STATE_BUS_OFF &&
12801240 can->can.state != CAN_STATE_ERROR_ACTIVE) {
1281− mod_timer(&can->bec_poll_timer,
1282− KVASER_PCIEFD_BEC_POLL_FREQ);
1241+ mod_timer(&can->bec_poll_timer, KVASER_PCIEFD_BEC_POLL_FREQ);
12831242 }
12841243 } else if (p->header[0] & KVASER_PCIEFD_SPACK_RMCD &&
1285− !(status & KVASER_PCIEFD_KCAN_STAT_BUS_OFF_MSK)) {
1244+ !(status & KVASER_PCIEFD_KCAN_STAT_BUS_OFF_MASK)) {
12861245 /* Reset to bus on detected */
12871246 if (!completion_done(&can->start_comp))
12881247 complete(&can->start_comp);
@@ -1295,12 +1254,10 @@ static void kvaser_pciefd_handle_nack_packet(struct kvaser_pciefd_can *can, · 6 unmodified lines
12951254 struct kvaser_pciefd_rx_packet *p)
12961255 {
12971256 struct sk_buff *skb;
1298− struct net_device_stats *stats = &can->can.dev->stats;
12991257 struct can_frame *cf;
13001258
13011259 skb = alloc_can_err_skb(can->can.dev, &cf);
1302−
1303− stats->tx_errors++;
1260+ can->can.dev->stats.tx_errors++;
13041261 if (p->header[0] & KVASER_PCIEFD_APACKET_ABL) {
13051262 if (skb)
13061263 cf->can_id |= CAN_ERR_LOSTARB;
@@ -1314,7 +1271,7 @@ static void kvaser_pciefd_handle_nack_packet(struct kvaser_pciefd_can *can, · 7 unmodified lines
13141271 kvaser_pciefd_set_skb_timestamp(can->kv_pcie, skb, p->timestamp);
13151272 netif_rx(skb);
13161273 } else {
1317− stats->rx_dropped++;
1274+ can->can.dev->stats.rx_dropped++;
13181275 netdev_warn(can->can.dev, "No memory left for err_skb\n");
13191276 }
13201277 }
@@ -1343,26 +1300,24 @@ static int kvaser_pciefd_handle_ack_packet(struct kvaser_pciefd *pcie, · 22 unmodified lines
13431300 netdev_dbg(can->can.dev, "Packet was flushed\n");
13441301 } else {
13451302 int echo_idx = FIELD_GET(KVASER_PCIEFD_PACKET_SEQ_MASK, p->header[0]);
1346− int dlc;
1303+ int len;
13471304 u8 count;
13481305 struct sk_buff *skb;
13491306
13501307 skb = can->can.echo_skb[echo_idx];
13511308 if (skb)
13521309 kvaser_pciefd_set_skb_timestamp(pcie, skb, p->timestamp);
1353− dlc = can_get_echo_skb(can->can.dev, echo_idx, NULL);
1310+ len = can_get_echo_skb(can->can.dev, echo_idx, NULL);
13541311 count = FIELD_GET(KVASER_PCIEFD_KCAN_TX_NR_PACKETS_CURRENT_MASK,
1355− ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NPACKETS_REG));
1312+ ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NR_PACKETS_REG));
13561313
13571314 if (count < KVASER_PCIEFD_CAN_TX_MAX_COUNT &&
13581315 netif_queue_stopped(can->can.dev))
13591316 netif_wake_queue(can->can.dev);
13601317
13611318 if (!one_shot_fail) {
1362− struct net_device_stats *stats = &can->can.dev->stats;
1363−
1364− stats->tx_bytes += dlc;
1365− stats->tx_packets++;
1319+ can->can.dev->stats.tx_bytes += len;
1320+ can->can.dev->stats.tx_packets++;
13661321 }
13671322 }
13681323
@@ -1562,13 +1517,12 @@ static irqreturn_t kvaser_pciefd_irq_handler(int irq, void *dev) · 193 unmodified lines
15621517 static void kvaser_pciefd_teardown_can_ctrls(struct kvaser_pciefd *pcie)
15631518 {
15641519 int i;
1565− struct kvaser_pciefd_can *can;
15661520
15671521 for (i = 0; i < pcie->nr_channels; i++) {
1568− can = pcie->can[i];
1522+ struct kvaser_pciefd_can *can = pcie->can[i];
1523+
15691524 if (can) {
1570− iowrite32(0,
1571− can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
1525+ iowrite32(0, can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
15721526 kvaser_pciefd_pwm_stop(can);
15731527 free_candev(can->can.dev);
15741528 }
@@ -1669,14 +1623,13 @@ err_disable_pci: · 94 unmodified lines
16691623
16701624 static void kvaser_pciefd_remove_all_ctrls(struct kvaser_pciefd *pcie)
16711625 {
1672− struct kvaser_pciefd_can *can;
16731626 int i;
16741627
16751628 for (i = 0; i < pcie->nr_channels; i++) {
1676− can = pcie->can[i];
1629+ struct kvaser_pciefd_can *can = pcie->can[i];
1630+
16771631 if (can) {
1678− iowrite32(0,
1679− can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
1632+ iowrite32(0, can->reg_base + KVASER_PCIEFD_KCAN_IEN_REG);
16801633 unregister_candev(can->can.dev);
16811634 del_timer(&can->bec_poll_timer);
16821635 kvaser_pciefd_pwm_stop(can);

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t