Lines Matching +full:cdr +full:- +full:mode
2 * sja1000.c - Philips SJA1000 network device driver
7 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
91 * the write_reg() operation - especially on SMP systems.
93 spin_lock_irqsave(&priv->cmdreg_lock, flags);
94 priv->write_reg(priv, SJA1000_CMR, val);
95 priv->read_reg(priv, SJA1000_SR);
96 spin_unlock_irqrestore(&priv->cmdreg_lock, flags);
101 return (priv->read_reg(priv, SJA1000_MOD) == 0xFF);
108 if (priv->reg_base && sja1000_is_absent(priv)) {
112 return -1;
118 unsigned char status = priv->read_reg(priv, SJA1000_MOD);
122 priv->write_reg(priv, SJA1000_IER, IRQ_OFF);
127 priv->can.state = CAN_STATE_STOPPED;
132 priv->write_reg(priv, SJA1000_MOD, MOD_RM);
134 status = priv->read_reg(priv, SJA1000_MOD);
137 netdev_err(dev, "setting SJA1000 into reset mode failed!\n");
143 unsigned char status = priv->read_reg(priv, SJA1000_MOD);
150 priv->can.state = CAN_STATE_ERROR_ACTIVE;
152 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
153 priv->write_reg(priv, SJA1000_IER, IRQ_ALL);
155 priv->write_reg(priv, SJA1000_IER,
160 /* set chip to normal mode */
161 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
163 if (priv->can.ctrlmode & CAN_CTRLMODE_PRESUME_ACK)
165 priv->write_reg(priv, SJA1000_MOD, mod_reg_val);
169 status = priv->read_reg(priv, SJA1000_MOD);
172 netdev_err(dev, "setting SJA1000 into normal mode failed!\n");
177 * - reset chip
178 * - set output mode
179 * - set baudrate
180 * - enable interrupts
181 * - start operating mode
187 if (!(priv->flags & SJA1000_QUIRK_NO_CDR_REG))
189 priv->write_reg(priv, SJA1000_CDR, priv->cdr | CDR_PELICAN);
192 priv->write_reg(priv, SJA1000_ACCC0, 0x00);
193 priv->write_reg(priv, SJA1000_ACCC1, 0x00);
194 priv->write_reg(priv, SJA1000_ACCC2, 0x00);
195 priv->write_reg(priv, SJA1000_ACCC3, 0x00);
197 priv->write_reg(priv, SJA1000_ACCM0, 0xFF);
198 priv->write_reg(priv, SJA1000_ACCM1, 0xFF);
199 priv->write_reg(priv, SJA1000_ACCM2, 0xFF);
200 priv->write_reg(priv, SJA1000_ACCM3, 0xFF);
202 priv->write_reg(priv, SJA1000_OCR, priv->ocr | OCR_MODE_NORMAL);
209 /* enter reset mode */
210 if (priv->can.state != CAN_STATE_STOPPED)
214 if (!(priv->flags & SJA1000_QUIRK_NO_CDR_REG ||
215 priv->read_reg(priv, SJA1000_CDR) & CDR_PELICAN))
219 priv->write_reg(priv, SJA1000_TXERR, 0x0);
220 priv->write_reg(priv, SJA1000_RXERR, 0x0);
221 priv->read_reg(priv, SJA1000_ECC);
224 priv->read_reg(priv, SJA1000_IR);
226 /* leave reset mode */
230 static int sja1000_set_mode(struct net_device *dev, enum can_mode mode)
232 switch (mode) {
240 return -EOPNOTSUPP;
249 struct can_bittiming *bt = &priv->can.bittiming;
252 btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
253 btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
254 (((bt->phase_seg2 - 1) & 0x7) << 4);
255 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
260 priv->write_reg(priv, SJA1000_BTR0, btr0);
261 priv->write_reg(priv, SJA1000_BTR1, btr1);
271 bec->txerr = priv->read_reg(priv, SJA1000_TXERR);
272 bec->rxerr = priv->read_reg(priv, SJA1000_RXERR);
281 * [ can-id ] [flags] [len] [can data (up to 8 bytes]
287 struct can_frame *cf = (struct can_frame *)skb->data;
299 fi = can_get_cc_dlc(cf, priv->can.ctrlmode);
300 id = cf->can_id;
308 priv->write_reg(priv, SJA1000_FI, fi);
309 priv->write_reg(priv, SJA1000_ID1, (id & 0x1fe00000) >> 21);
310 priv->write_reg(priv, SJA1000_ID2, (id & 0x001fe000) >> 13);
311 priv->write_reg(priv, SJA1000_ID3, (id & 0x00001fe0) >> 5);
312 priv->write_reg(priv, SJA1000_ID4, (id & 0x0000001f) << 3);
315 priv->write_reg(priv, SJA1000_FI, fi);
316 priv->write_reg(priv, SJA1000_ID1, (id & 0x000007f8) >> 3);
317 priv->write_reg(priv, SJA1000_ID2, (id & 0x00000007) << 5);
320 for (i = 0; i < cf->len; i++)
321 priv->write_reg(priv, dreg++, cf->data[i]);
325 if (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
328 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
341 struct net_device_stats *stats = &dev->stats;
354 fi = priv->read_reg(priv, SJA1000_FI);
359 id = (priv->read_reg(priv, SJA1000_ID1) << 21)
360 | (priv->read_reg(priv, SJA1000_ID2) << 13)
361 | (priv->read_reg(priv, SJA1000_ID3) << 5)
362 | (priv->read_reg(priv, SJA1000_ID4) >> 3);
367 id = (priv->read_reg(priv, SJA1000_ID1) << 3)
368 | (priv->read_reg(priv, SJA1000_ID2) >> 5);
371 can_frame_set_cc_len(cf, fi & 0x0F, priv->can.ctrlmode);
375 for (i = 0; i < cf->len; i++)
376 cf->data[i] = priv->read_reg(priv, dreg++);
378 stats->rx_bytes += cf->len;
380 stats->rx_packets++;
382 cf->can_id = id;
409 struct net_device_stats *stats = &dev->stats;
412 enum can_state state = priv->can.state;
420 txerr = priv->read_reg(priv, SJA1000_TXERR);
421 rxerr = priv->read_reg(priv, SJA1000_RXERR);
427 cf->can_id |= CAN_ERR_CRTL;
428 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
431 stats->rx_over_errors++;
432 stats->rx_errors++;
438 * way to re-sync the read vs. write buffer offsets is to
441 if (priv->flags & SJA1000_QUIRK_RESET_ON_OVERRUN)
457 cf->can_id |= CAN_ERR_CNT;
458 cf->data[6] = txerr;
459 cf->data[7] = rxerr;
463 priv->can.can_stats.bus_error++;
465 ecc = priv->read_reg(priv, SJA1000_ECC);
467 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
472 cf->data[2] |= CAN_ERR_PROT_BIT;
475 cf->data[2] |= CAN_ERR_PROT_FORM;
478 cf->data[2] |= CAN_ERR_PROT_STUFF;
485 cf->data[3] = ecc & ECC_SEG;
490 stats->tx_errors++;
492 cf->data[2] |= CAN_ERR_PROT_TX;
494 stats->rx_errors++;
509 alc = priv->read_reg(priv, SJA1000_ALC);
510 priv->can.can_stats.arbitration_lost++;
512 cf->can_id |= CAN_ERR_LOSTARB;
513 cf->data[0] = alc & 0x1f;
517 if (state != priv->can.state) {
528 return -ENOMEM;
539 struct net_device_stats *stats = &dev->stats;
544 if (priv->pre_irq)
545 priv->pre_irq(priv);
548 if (priv->read_reg(priv, SJA1000_IER) == IRQ_OFF)
551 while ((isrc = priv->read_reg(priv, SJA1000_IR)) &&
554 status = priv->read_reg(priv, SJA1000_SR);
564 if (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT &&
566 stats->tx_errors++;
570 stats->tx_bytes += can_get_echo_skb(dev, 0, NULL);
571 stats->tx_packets++;
579 status = priv->read_reg(priv, SJA1000_SR);
599 if (priv->post_irq)
600 priv->post_irq(priv);
614 /* set chip into reset mode */
623 if (!(priv->flags & SJA1000_CUSTOM_IRQ_HANDLER)) {
624 err = request_threaded_irq(dev->irq, sja1000_interrupt,
626 priv->irq_flags, dev->name, (void *)dev);
629 return -EAGAIN;
648 if (!(priv->flags & SJA1000_CUSTOM_IRQ_HANDLER))
649 free_irq(dev->irq, (void *)dev);
668 priv->dev = dev;
669 priv->can.bittiming_const = &sja1000_bittiming_const;
670 priv->can.do_set_bittiming = sja1000_set_bittiming;
671 priv->can.do_set_mode = sja1000_set_mode;
672 priv->can.do_get_berr_counter = sja1000_get_berr_counter;
673 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
681 spin_lock_init(&priv->cmdreg_lock);
684 priv->priv = (void *)priv + sizeof(struct sja1000_priv);
710 return -ENODEV;
712 dev->flags |= IFF_ECHO; /* we support local echo */
713 dev->netdev_ops = &sja1000_netdev_ops;
714 dev->ethtool_ops = &sja1000_ethtool_ops;