static void ti_hecc_stop(struct net_device *ndev) { struct ti_hecc_priv *priv = netdev_priv(ndev); /* Disable interrupts and disable mailboxes */ hecc_write(priv, HECC_CANGIM, 0); hecc_write(priv, HECC_CANMIM, 0); hecc_write(priv, HECC_CANME, 0); priv->can.state = CAN_STATE_STOPPED; }
static int ti_hecc_set_btc(struct ti_hecc_priv *priv) { struct can_bittiming *bit_timing = &priv->can.bittiming; u32 can_btc; can_btc = (bit_timing->phase_seg2 - 1) & 0x7; can_btc |= ((bit_timing->phase_seg1 + bit_timing->prop_seg - 1) & 0xF) << 3; if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) { if (bit_timing->brp > 4) can_btc |= HECC_CANBTC_SAM; else netdev_warn(priv->ndev, "WARN: Triple" "sampling not set due to h/w limitations"); } can_btc |= ((bit_timing->sjw - 1) & 0x3) << 8; can_btc |= ((bit_timing->brp - 1) & 0xFF) << 16; /* ERM being set to 0 by default meaning resync at falling edge */ hecc_write(priv, HECC_CANBTC, can_btc); netdev_info(priv->ndev, "setting CANBTC=%#x\n", can_btc); return 0; }
/* * ti_hecc_rx_poll - HECC receive pkts * * The receive mailboxes start from highest numbered mailbox till last xmit * mailbox. On CAN frame reception the hardware places the data into highest * numbered mailbox that matches the CAN ID filter. Since all receive mailboxes * have same filtering (ALL CAN frames) packets will arrive in the highest * available RX mailbox and we need to ensure in-order packet reception. * * To ensure the packets are received in the right order we logically divide * the RX mailboxes into main and buffer mailboxes. Packets are received as per * mailbox priotity (higher to lower) in the main bank and once it is full we * disable further reception into main mailboxes. While the main mailboxes are * processed in NAPI, further packets are received in buffer mailboxes. * * We maintain a RX next mailbox counter to process packets and once all main * mailboxe packets are passed to the upper stack we enable all of them but * continue to process packets received in buffer mailboxes. With each packet * received from buffer mailbox we enable it immediately so as to handle the * overflow from higher mailboxes. */ static int ti_hecc_rx_poll(struct napi_struct *napi, int quota) { struct net_device *ndev = napi->dev; struct ti_hecc_priv *priv = netdev_priv(ndev); u32 num_pkts = 0; u32 mbx_mask; unsigned long pending_pkts, flags; if (!netif_running(ndev)) return 0; while ((pending_pkts = hecc_read(priv, HECC_CANRMP)) && num_pkts < quota) { mbx_mask = BIT(priv->rx_next); /* next rx mailbox to process */ if (mbx_mask & pending_pkts) { if (ti_hecc_rx_pkt(priv, priv->rx_next) < 0) return num_pkts; ++num_pkts; } else if (priv->rx_next > HECC_RX_BUFFER_MBOX) { break; /* pkt not received yet */ } --priv->rx_next; if (priv->rx_next == HECC_RX_BUFFER_MBOX) { /* enable high bank mailboxes */ spin_lock_irqsave(&priv->mbx_lock, flags); mbx_mask = hecc_read(priv, HECC_CANME); mbx_mask |= HECC_RX_HIGH_MBOX_MASK; hecc_write(priv, HECC_CANME, mbx_mask); spin_unlock_irqrestore(&priv->mbx_lock, flags); } else if (priv->rx_next == HECC_MAX_TX_MBOX - 1) { priv->rx_next = HECC_RX_FIRST_MBOX; break; } } /* Enable packet interrupt if all pkts are handled */ if (hecc_read(priv, HECC_CANRMP) == 0) { napi_complete(napi); /* Re-enable RX mailbox interrupts */ mbx_mask = hecc_read(priv, HECC_CANMIM); mbx_mask |= HECC_TX_MBOX_MASK; hecc_write(priv, HECC_CANMIM, mbx_mask); } return num_pkts; }
/* * ti_hecc_xmit: HECC Transmit * * The transmit mailboxes start from 0 to HECC_MAX_TX_MBOX. In HECC the * priority of the mailbox for tranmission is dependent upon priority setting * field in mailbox registers. The mailbox with highest value in priority field * is transmitted first. Only when two mailboxes have the same value in * priority field the highest numbered mailbox is transmitted first. * * To utilize the HECC priority feature as described above we start with the * highest numbered mailbox with highest priority level and move on to the next * mailbox with the same priority level and so on. Once we loop through all the * transmit mailboxes we choose the next priority level (lower) and so on * until we reach the lowest priority level on the lowest numbered mailbox * when we stop transmission until all mailboxes are transmitted and then * restart at highest numbered mailbox with highest priority. * * Two counters (head and tail) are used to track the next mailbox to transmit * and to track the echo buffer for already transmitted mailbox. The queue * is stopped when all the mailboxes are busy or when there is a priority * value roll-over happens. */ static netdev_tx_t ti_hecc_xmit(struct sk_buff *skb, struct net_device *ndev) { struct ti_hecc_priv *priv = netdev_priv(ndev); struct can_frame *cf = (struct can_frame *)skb->data; u32 mbxno, mbx_mask, data; unsigned long flags; if (can_dropped_invalid_skb(ndev, skb)) return NETDEV_TX_OK; mbxno = get_tx_head_mb(priv); mbx_mask = BIT(mbxno); spin_lock_irqsave(&priv->mbx_lock, flags); if (unlikely(hecc_read(priv, HECC_CANME) & mbx_mask)) { spin_unlock_irqrestore(&priv->mbx_lock, flags); netif_stop_queue(ndev); netdev_err(priv->ndev, "BUG: TX mbx not ready tx_head=%08X, tx_tail=%08X\n", priv->tx_head, priv->tx_tail); return NETDEV_TX_BUSY; } spin_unlock_irqrestore(&priv->mbx_lock, flags); /* Prepare mailbox for transmission */ data = cf->can_dlc | (get_tx_head_prio(priv) << 8); if (cf->can_id & CAN_RTR_FLAG) /* Remote transmission request */ data |= HECC_CANMCF_RTR; hecc_write_mbx(priv, mbxno, HECC_CANMCF, data); if (cf->can_id & CAN_EFF_FLAG) /* Extended frame format */ data = (cf->can_id & CAN_EFF_MASK) | HECC_CANMID_IDE; else /* Standard frame format */ data = (cf->can_id & CAN_SFF_MASK) << 18; hecc_write_mbx(priv, mbxno, HECC_CANMID, data); hecc_write_mbx(priv, mbxno, HECC_CANMDL, be32_to_cpu(*(u32 *)(cf->data))); if (cf->can_dlc > 4) hecc_write_mbx(priv, mbxno, HECC_CANMDH, be32_to_cpu(*(u32 *)(cf->data + 4))); else *(u32 *)(cf->data + 4) = 0; can_put_echo_skb(skb, ndev, mbxno); spin_lock_irqsave(&priv->mbx_lock, flags); --priv->tx_head; if ((hecc_read(priv, HECC_CANME) & BIT(get_tx_head_mb(priv))) || (priv->tx_head & HECC_TX_MASK) == HECC_TX_MASK) { netif_stop_queue(ndev); } hecc_set_bit(priv, HECC_CANME, mbx_mask); spin_unlock_irqrestore(&priv->mbx_lock, flags); hecc_clear_bit(priv, HECC_CANMD, mbx_mask); hecc_set_bit(priv, HECC_CANMIM, mbx_mask); hecc_write(priv, HECC_CANTRS, mbx_mask); return NETDEV_TX_OK; }
static int ti_hecc_rx_pkt(struct ti_hecc_priv *priv, int mbxno) { struct net_device_stats *stats = &priv->ndev->stats; struct can_frame *cf; struct sk_buff *skb; u32 data, mbx_mask; unsigned long flags; skb = alloc_can_skb(priv->ndev, &cf); if (!skb) { if (printk_ratelimit()) netdev_err(priv->ndev, "ti_hecc_rx_pkt: alloc_can_skb() failed\n"); return -ENOMEM; } mbx_mask = BIT(mbxno); data = hecc_read_mbx(priv, mbxno, HECC_CANMID); if (data & HECC_CANMID_IDE) cf->can_id = (data & CAN_EFF_MASK) | CAN_EFF_FLAG; else cf->can_id = (data >> 18) & CAN_SFF_MASK; data = hecc_read_mbx(priv, mbxno, HECC_CANMCF); if (data & HECC_CANMCF_RTR) cf->can_id |= CAN_RTR_FLAG; cf->can_dlc = get_can_dlc(data & 0xF); data = hecc_read_mbx(priv, mbxno, HECC_CANMDL); *(u32 *)(cf->data) = cpu_to_be32(data); if (cf->can_dlc > 4) { data = hecc_read_mbx(priv, mbxno, HECC_CANMDH); *(u32 *)(cf->data + 4) = cpu_to_be32(data); } else { *(u32 *)(cf->data + 4) = 0; } spin_lock_irqsave(&priv->mbx_lock, flags); hecc_clear_bit(priv, HECC_CANME, mbx_mask); hecc_write(priv, HECC_CANRMP, mbx_mask); /* enable mailbox only if it is part of rx buffer mailboxes */ if (priv->rx_next < HECC_RX_BUFFER_MBOX) hecc_set_bit(priv, HECC_CANME, mbx_mask); spin_unlock_irqrestore(&priv->mbx_lock, flags); stats->rx_bytes += cf->can_dlc; can_led_event(priv->ndev, CAN_LED_EVENT_RX); netif_receive_skb(skb); stats->rx_packets++; return 0; }
static void ti_hecc_start(struct net_device *ndev) { struct ti_hecc_priv *priv = netdev_priv(ndev); u32 cnt, mbxno, mbx_mask; /* put HECC in initialization mode and set btc */ ti_hecc_reset(ndev); priv->tx_head = priv->tx_tail = HECC_TX_MASK; priv->rx_next = HECC_RX_FIRST_MBOX; /* Enable local and global acceptance mask registers */ hecc_write(priv, HECC_CANGAM, HECC_SET_REG); /* Prepare configured mailboxes to receive messages */ for (cnt = 0; cnt < HECC_MAX_RX_MBOX; cnt++) { mbxno = HECC_MAX_MAILBOXES - 1 - cnt; mbx_mask = BIT(mbxno); hecc_clear_bit(priv, HECC_CANME, mbx_mask); hecc_write_mbx(priv, mbxno, HECC_CANMID, HECC_CANMID_AME); hecc_write_lam(priv, mbxno, HECC_SET_REG); hecc_set_bit(priv, HECC_CANMD, mbx_mask); hecc_set_bit(priv, HECC_CANME, mbx_mask); hecc_set_bit(priv, HECC_CANMIM, mbx_mask); } /* Prevent message over-write & Enable interrupts */ hecc_write(priv, HECC_CANOPC, HECC_SET_REG); if (priv->int_line) { hecc_write(priv, HECC_CANMIL, HECC_SET_REG); hecc_write(priv, HECC_CANGIM, HECC_CANGIM_DEF_MASK | HECC_CANGIM_I1EN | HECC_CANGIM_SIL); } else { hecc_write(priv, HECC_CANMIL, 0); hecc_write(priv, HECC_CANGIM, HECC_CANGIM_DEF_MASK | HECC_CANGIM_I0EN); } priv->can.state = CAN_STATE_ERROR_ACTIVE; }
static irqreturn_t ti_hecc_interrupt(int irq, void *dev_id) { struct net_device *ndev = (struct net_device *)dev_id; struct ti_hecc_priv *priv = netdev_priv(ndev); struct net_device_stats *stats = &ndev->stats; u32 mbxno, mbx_mask, int_status, err_status; unsigned long ack, flags; int_status = hecc_read(priv, (priv->int_line) ? HECC_CANGIF1 : HECC_CANGIF0); if (!int_status) return IRQ_NONE; err_status = hecc_read(priv, HECC_CANES); if (err_status & (HECC_BUS_ERROR | HECC_CANES_BO | HECC_CANES_EP | HECC_CANES_EW)) ti_hecc_error(ndev, int_status, err_status); if (int_status & HECC_CANGIF_GMIF) { while (priv->tx_tail - priv->tx_head > 0) { mbxno = get_tx_tail_mb(priv); mbx_mask = BIT(mbxno); if (!(mbx_mask & hecc_read(priv, HECC_CANTA))) break; hecc_clear_bit(priv, HECC_CANMIM, mbx_mask); hecc_write(priv, HECC_CANTA, mbx_mask); spin_lock_irqsave(&priv->mbx_lock, flags); hecc_clear_bit(priv, HECC_CANME, mbx_mask); spin_unlock_irqrestore(&priv->mbx_lock, flags); stats->tx_bytes += hecc_read_mbx(priv, mbxno, HECC_CANMCF) & 0xF; stats->tx_packets++; can_get_echo_skb(ndev, mbxno); --priv->tx_tail; } /* restart queue if wrap-up or if queue stalled on last pkt */ if (((priv->tx_head == priv->tx_tail) && ((priv->tx_head & HECC_TX_MASK) != HECC_TX_MASK)) || (((priv->tx_tail & HECC_TX_MASK) == HECC_TX_MASK) && ((priv->tx_head & HECC_TX_MASK) == HECC_TX_MASK))) netif_wake_queue(ndev); /* Disable RX mailbox interrupts and let NAPI reenable them */ if (hecc_read(priv, HECC_CANRMP)) { ack = hecc_read(priv, HECC_CANMIM); ack &= BIT(HECC_MAX_TX_MBOX) - 1; hecc_write(priv, HECC_CANMIM, ack); napi_schedule(&priv->napi); } } /* clear all interrupt conditions - read back to avoid spurious ints */ if (priv->int_line) { hecc_write(priv, HECC_CANGIF1, HECC_SET_REG); int_status = hecc_read(priv, HECC_CANGIF1); } else { hecc_write(priv, HECC_CANGIF0, HECC_SET_REG); int_status = hecc_read(priv, HECC_CANGIF0); } return IRQ_HANDLED; }
static int ti_hecc_error(struct net_device *ndev, int int_status, int err_status) { struct ti_hecc_priv *priv = netdev_priv(ndev); struct net_device_stats *stats = &ndev->stats; struct can_frame *cf; struct sk_buff *skb; /* propagate the error condition to the can stack */ skb = alloc_can_err_skb(ndev, &cf); if (!skb) { if (printk_ratelimit()) netdev_err(priv->ndev, "ti_hecc_error: alloc_can_err_skb() failed\n"); return -ENOMEM; } if (int_status & HECC_CANGIF_WLIF) { /* warning level int */ if ((int_status & HECC_CANGIF_BOIF) == 0) { priv->can.state = CAN_STATE_ERROR_WARNING; ++priv->can.can_stats.error_warning; cf->can_id |= CAN_ERR_CRTL; if (hecc_read(priv, HECC_CANTEC) > 96) cf->data[1] |= CAN_ERR_CRTL_TX_WARNING; if (hecc_read(priv, HECC_CANREC) > 96) cf->data[1] |= CAN_ERR_CRTL_RX_WARNING; } hecc_set_bit(priv, HECC_CANES, HECC_CANES_EW); netdev_dbg(priv->ndev, "Error Warning interrupt\n"); hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR); } if (int_status & HECC_CANGIF_EPIF) { /* error passive int */ if ((int_status & HECC_CANGIF_BOIF) == 0) { priv->can.state = CAN_STATE_ERROR_PASSIVE; ++priv->can.can_stats.error_passive; cf->can_id |= CAN_ERR_CRTL; if (hecc_read(priv, HECC_CANTEC) > 127) cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE; if (hecc_read(priv, HECC_CANREC) > 127) cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE; } hecc_set_bit(priv, HECC_CANES, HECC_CANES_EP); netdev_dbg(priv->ndev, "Error passive interrupt\n"); hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR); } /* * Need to check busoff condition in error status register too to * ensure warning interrupts don't hog the system */ if ((int_status & HECC_CANGIF_BOIF) || (err_status & HECC_CANES_BO)) { priv->can.state = CAN_STATE_BUS_OFF; cf->can_id |= CAN_ERR_BUSOFF; hecc_set_bit(priv, HECC_CANES, HECC_CANES_BO); hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_CCR); /* Disable all interrupts in bus-off to avoid int hog */ hecc_write(priv, HECC_CANGIM, 0); can_bus_off(ndev); } if (err_status & HECC_BUS_ERROR) { ++priv->can.can_stats.bus_error; cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT; cf->data[2] |= CAN_ERR_PROT_UNSPEC; if (err_status & HECC_CANES_FE) { hecc_set_bit(priv, HECC_CANES, HECC_CANES_FE); cf->data[2] |= CAN_ERR_PROT_FORM; } if (err_status & HECC_CANES_BE) { hecc_set_bit(priv, HECC_CANES, HECC_CANES_BE); cf->data[2] |= CAN_ERR_PROT_BIT; } if (err_status & HECC_CANES_SE) { hecc_set_bit(priv, HECC_CANES, HECC_CANES_SE); cf->data[2] |= CAN_ERR_PROT_STUFF; } if (err_status & HECC_CANES_CRCE) { hecc_set_bit(priv, HECC_CANES, HECC_CANES_CRCE); cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ | CAN_ERR_PROT_LOC_CRC_DEL; } if (err_status & HECC_CANES_ACKE) { hecc_set_bit(priv, HECC_CANES, HECC_CANES_ACKE); cf->data[3] |= CAN_ERR_PROT_LOC_ACK | CAN_ERR_PROT_LOC_ACK_DEL; } } netif_rx(skb); stats->rx_packets++; stats->rx_bytes += cf->can_dlc; return 0; }
static void ti_hecc_reset(struct net_device *ndev) { u32 cnt; struct ti_hecc_priv *priv = netdev_priv(ndev); netdev_dbg(ndev, "resetting hecc ...\n"); hecc_set_bit(priv, HECC_CANMC, HECC_CANMC_SRES); /* Set change control request and wait till enabled */ hecc_set_bit(priv, HECC_CANMC, HECC_CANMC_CCR); /* * INFO: It has been observed that at times CCE bit may not be * set and hw seems to be ok even if this bit is not set so * timing out with a timing of 1ms to respect the specs */ cnt = HECC_CCE_WAIT_COUNT; while (!hecc_get_bit(priv, HECC_CANES, HECC_CANES_CCE) && cnt != 0) { --cnt; udelay(10); } /* * Note: On HECC, BTC can be programmed only in initialization mode, so * it is expected that the can bittiming parameters are set via ip * utility before the device is opened */ ti_hecc_set_btc(priv); /* Clear CCR (and CANMC register) and wait for CCE = 0 enable */ hecc_write(priv, HECC_CANMC, 0); /* * INFO: CAN net stack handles bus off and hence disabling auto-bus-on * hecc_set_bit(priv, HECC_CANMC, HECC_CANMC_ABO); */ /* * INFO: It has been observed that at times CCE bit may not be * set and hw seems to be ok even if this bit is not set so */ cnt = HECC_CCE_WAIT_COUNT; while (hecc_get_bit(priv, HECC_CANES, HECC_CANES_CCE) && cnt != 0) { --cnt; udelay(10); } /* Enable TX and RX I/O Control pins */ hecc_write(priv, HECC_CANTIOC, HECC_CANTIOC_EN); hecc_write(priv, HECC_CANRIOC, HECC_CANRIOC_EN); /* Clear registers for clean operation */ hecc_write(priv, HECC_CANTA, HECC_SET_REG); hecc_write(priv, HECC_CANRMP, HECC_SET_REG); hecc_write(priv, HECC_CANGIF0, HECC_SET_REG); hecc_write(priv, HECC_CANGIF1, HECC_SET_REG); hecc_write(priv, HECC_CANME, 0); hecc_write(priv, HECC_CANMD, 0); /* SCC compat mode NOT supported (and not needed too) */ hecc_set_bit(priv, HECC_CANMC, HECC_CANMC_SCM); }
static inline void hecc_clear_bit(struct ti_hecc_priv *priv, int reg, u32 bit_mask) { hecc_write(priv, reg, hecc_read(priv, reg) & ~bit_mask); }