2 * Driver for Microchip MRF24J40 802.15.4 Wireless-PAN Networking controller
4 * Copyright (C) 2012 Alan Ott <alan@signal11.us>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <linux/spi/spi.h>
23 #include <linux/interrupt.h>
24 #include <linux/module.h>
25 #include <linux/pinctrl/consumer.h>
26 #include <net/wpan-phy.h>
27 #include <net/mac802154.h>
29 /* MRF24J40 Short Address Registers */
30 #define REG_RXMCR 0x00 /* Receive MAC control */
31 #define REG_PANIDL 0x01 /* PAN ID (low) */
32 #define REG_PANIDH 0x02 /* PAN ID (high) */
33 #define REG_SADRL 0x03 /* Short address (low) */
34 #define REG_SADRH 0x04 /* Short address (high) */
35 #define REG_EADR0 0x05 /* Long address (low) (high is EADR7) */
36 #define REG_TXMCR 0x11 /* Transmit MAC control */
37 #define REG_PACON0 0x16 /* Power Amplifier Control */
38 #define REG_PACON1 0x17 /* Power Amplifier Control */
39 #define REG_PACON2 0x18 /* Power Amplifier Control */
40 #define REG_TXNCON 0x1B /* Transmit Normal FIFO Control */
41 #define REG_TXSTAT 0x24 /* TX MAC Status Register */
42 #define REG_SOFTRST 0x2A /* Soft Reset */
43 #define REG_TXSTBL 0x2E /* TX Stabilization */
44 #define REG_INTSTAT 0x31 /* Interrupt Status */
45 #define REG_INTCON 0x32 /* Interrupt Control */
46 #define REG_RFCTL 0x36 /* RF Control Mode Register */
47 #define REG_BBREG1 0x39 /* Baseband Registers */
48 #define REG_BBREG2 0x3A /* */
49 #define REG_BBREG6 0x3E /* */
50 #define REG_CCAEDTH 0x3F /* Energy Detection Threshold */
52 /* MRF24J40 Long Address Registers */
53 #define REG_RFCON0 0x200 /* RF Control Registers */
54 #define REG_RFCON1 0x201
55 #define REG_RFCON2 0x202
56 #define REG_RFCON3 0x203
57 #define REG_RFCON5 0x205
58 #define REG_RFCON6 0x206
59 #define REG_RFCON7 0x207
60 #define REG_RFCON8 0x208
61 #define REG_RSSI 0x210
62 #define REG_SLPCON0 0x211 /* Sleep Clock Control Registers */
63 #define REG_SLPCON1 0x220
64 #define REG_WAKETIMEL 0x222 /* Wake-up Time Match Value Low */
65 #define REG_WAKETIMEH 0x223 /* Wake-up Time Match Value High */
66 #define REG_RX_FIFO 0x300 /* Receive FIFO */
68 /* Device configuration: Only channels 11-26 on page 0 are supported. */
69 #define MRF24J40_CHAN_MIN 11
70 #define MRF24J40_CHAN_MAX 26
71 #define CHANNEL_MASK (((u32)1 << (MRF24J40_CHAN_MAX + 1)) \
72 - ((u32)1 << MRF24J40_CHAN_MIN))
74 #define TX_FIFO_SIZE 128 /* From datasheet */
75 #define RX_FIFO_SIZE 144 /* From datasheet */
76 #define SET_CHANNEL_DELAY_US 192 /* From datasheet */
78 /* Device Private Data */
80 struct spi_device *spi;
81 struct ieee802154_dev *dev;
83 struct mutex buffer_mutex; /* only used to protect buf */
84 struct completion tx_complete;
85 struct work_struct irqwork;
86 u8 *buf; /* 3 bytes. Used for SPI single-register transfers. */
89 /* Read/Write SPI Commands for Short and Long Address registers. */
90 #define MRF24J40_READSHORT(reg) ((reg) << 1)
91 #define MRF24J40_WRITESHORT(reg) ((reg) << 1 | 1)
92 #define MRF24J40_READLONG(reg) (1 << 15 | (reg) << 5)
93 #define MRF24J40_WRITELONG(reg) (1 << 15 | (reg) << 5 | 1 << 4)
95 /* Maximum speed to run the device at. TODO: Get the real max value from
96 * someone at Microchip since it isn't in the datasheet. */
97 #define MAX_SPI_SPEED_HZ 1000000
99 #define printdev(X) (&X->spi->dev)
101 static int write_short_reg(struct mrf24j40 *devrec, u8 reg, u8 value)
104 struct spi_message msg;
105 struct spi_transfer xfer = {
107 .tx_buf = devrec->buf,
108 .rx_buf = devrec->buf,
111 spi_message_init(&msg);
112 spi_message_add_tail(&xfer, &msg);
114 mutex_lock(&devrec->buffer_mutex);
115 devrec->buf[0] = MRF24J40_WRITESHORT(reg);
116 devrec->buf[1] = value;
118 ret = spi_sync(devrec->spi, &msg);
120 dev_err(printdev(devrec),
121 "SPI write Failed for short register 0x%hhx\n", reg);
123 mutex_unlock(&devrec->buffer_mutex);
127 static int read_short_reg(struct mrf24j40 *devrec, u8 reg, u8 *val)
130 struct spi_message msg;
131 struct spi_transfer xfer = {
133 .tx_buf = devrec->buf,
134 .rx_buf = devrec->buf,
137 spi_message_init(&msg);
138 spi_message_add_tail(&xfer, &msg);
140 mutex_lock(&devrec->buffer_mutex);
141 devrec->buf[0] = MRF24J40_READSHORT(reg);
144 ret = spi_sync(devrec->spi, &msg);
146 dev_err(printdev(devrec),
147 "SPI read Failed for short register 0x%hhx\n", reg);
149 *val = devrec->buf[1];
151 mutex_unlock(&devrec->buffer_mutex);
155 static int read_long_reg(struct mrf24j40 *devrec, u16 reg, u8 *value)
159 struct spi_message msg;
160 struct spi_transfer xfer = {
162 .tx_buf = devrec->buf,
163 .rx_buf = devrec->buf,
166 spi_message_init(&msg);
167 spi_message_add_tail(&xfer, &msg);
169 cmd = MRF24J40_READLONG(reg);
170 mutex_lock(&devrec->buffer_mutex);
171 devrec->buf[0] = cmd >> 8 & 0xff;
172 devrec->buf[1] = cmd & 0xff;
175 ret = spi_sync(devrec->spi, &msg);
177 dev_err(printdev(devrec),
178 "SPI read Failed for long register 0x%hx\n", reg);
180 *value = devrec->buf[2];
182 mutex_unlock(&devrec->buffer_mutex);
186 static int write_long_reg(struct mrf24j40 *devrec, u16 reg, u8 val)
190 struct spi_message msg;
191 struct spi_transfer xfer = {
193 .tx_buf = devrec->buf,
194 .rx_buf = devrec->buf,
197 spi_message_init(&msg);
198 spi_message_add_tail(&xfer, &msg);
200 cmd = MRF24J40_WRITELONG(reg);
201 mutex_lock(&devrec->buffer_mutex);
202 devrec->buf[0] = cmd >> 8 & 0xff;
203 devrec->buf[1] = cmd & 0xff;
204 devrec->buf[2] = val;
206 ret = spi_sync(devrec->spi, &msg);
208 dev_err(printdev(devrec),
209 "SPI write Failed for long register 0x%hx\n", reg);
211 mutex_unlock(&devrec->buffer_mutex);
215 /* This function relies on an undocumented write method. Once a write command
216 and address is set, as many bytes of data as desired can be clocked into
217 the device. The datasheet only shows setting one byte at a time. */
218 static int write_tx_buf(struct mrf24j40 *devrec, u16 reg,
219 const u8 *data, size_t length)
224 struct spi_message msg;
225 struct spi_transfer addr_xfer = {
227 .tx_buf = devrec->buf,
229 struct spi_transfer lengths_xfer = {
231 .tx_buf = &lengths, /* TODO: Is DMA really required for SPI? */
233 struct spi_transfer data_xfer = {
238 /* Range check the length. 2 bytes are used for the length fields.*/
239 if (length > TX_FIFO_SIZE-2) {
240 dev_err(printdev(devrec), "write_tx_buf() was passed too large a buffer. Performing short write.\n");
241 length = TX_FIFO_SIZE-2;
244 spi_message_init(&msg);
245 spi_message_add_tail(&addr_xfer, &msg);
246 spi_message_add_tail(&lengths_xfer, &msg);
247 spi_message_add_tail(&data_xfer, &msg);
249 cmd = MRF24J40_WRITELONG(reg);
250 mutex_lock(&devrec->buffer_mutex);
251 devrec->buf[0] = cmd >> 8 & 0xff;
252 devrec->buf[1] = cmd & 0xff;
253 lengths[0] = 0x0; /* Header Length. Set to 0 for now. TODO */
254 lengths[1] = length; /* Total length */
256 ret = spi_sync(devrec->spi, &msg);
258 dev_err(printdev(devrec), "SPI write Failed for TX buf\n");
260 mutex_unlock(&devrec->buffer_mutex);
264 static int mrf24j40_read_rx_buf(struct mrf24j40 *devrec,
265 u8 *data, u8 *len, u8 *lqi)
272 struct spi_message msg;
273 struct spi_transfer addr_xfer = {
277 struct spi_transfer data_xfer = {
278 .len = 0x0, /* set below */
281 struct spi_transfer status_xfer = {
286 /* Get the length of the data in the RX FIFO. The length in this
287 * register exclues the 1-byte length field at the beginning. */
288 ret = read_long_reg(devrec, REG_RX_FIFO, &rx_len);
292 /* Range check the RX FIFO length, accounting for the one-byte
293 * length field at the begining. */
294 if (rx_len > RX_FIFO_SIZE-1) {
295 dev_err(printdev(devrec), "Invalid length read from device. Performing short read.\n");
296 rx_len = RX_FIFO_SIZE-1;
300 /* Passed in buffer wasn't big enough. Should never happen. */
301 dev_err(printdev(devrec), "Buffer not big enough. Performing short read\n");
305 /* Set up the commands to read the data. */
306 cmd = MRF24J40_READLONG(REG_RX_FIFO+1);
307 addr[0] = cmd >> 8 & 0xff;
308 addr[1] = cmd & 0xff;
309 data_xfer.len = rx_len;
311 spi_message_init(&msg);
312 spi_message_add_tail(&addr_xfer, &msg);
313 spi_message_add_tail(&data_xfer, &msg);
314 spi_message_add_tail(&status_xfer, &msg);
316 ret = spi_sync(devrec->spi, &msg);
318 dev_err(printdev(devrec), "SPI RX Buffer Read Failed.\n");
326 print_hex_dump(KERN_DEBUG, "mrf24j40 rx: ",
327 DUMP_PREFIX_OFFSET, 16, 1, data, *len, 0);
328 printk(KERN_DEBUG "mrf24j40 rx: lqi: %02hhx rssi: %02hhx\n",
329 lqi_rssi[0], lqi_rssi[1]);
336 static int mrf24j40_tx(struct ieee802154_dev *dev, struct sk_buff *skb)
338 struct mrf24j40 *devrec = dev->priv;
342 dev_dbg(printdev(devrec), "tx packet of %d bytes\n", skb->len);
344 ret = write_tx_buf(devrec, 0x000, skb->data, skb->len);
348 /* Set TXNTRIG bit of TXNCON to send packet */
349 ret = read_short_reg(devrec, REG_TXNCON, &val);
354 write_short_reg(devrec, REG_TXNCON, val);
356 INIT_COMPLETION(devrec->tx_complete);
358 /* Wait for the device to send the TX complete interrupt. */
359 ret = wait_for_completion_interruptible_timeout(
360 &devrec->tx_complete,
362 if (ret == -ERESTARTSYS)
369 /* Check for send error from the device. */
370 ret = read_short_reg(devrec, REG_TXSTAT, &val);
374 dev_err(printdev(devrec), "Error Sending. Retry count exceeded\n");
375 ret = -ECOMM; /* TODO: Better error code ? */
377 dev_dbg(printdev(devrec), "Packet Sent\n");
384 static int mrf24j40_ed(struct ieee802154_dev *dev, u8 *level)
387 printk(KERN_WARNING "mrf24j40: ed not implemented\n");
392 static int mrf24j40_start(struct ieee802154_dev *dev)
394 struct mrf24j40 *devrec = dev->priv;
398 dev_dbg(printdev(devrec), "start\n");
400 ret = read_short_reg(devrec, REG_INTCON, &val);
403 val &= ~(0x1|0x8); /* Clear TXNIE and RXIE. Enable interrupts */
404 write_short_reg(devrec, REG_INTCON, val);
409 static void mrf24j40_stop(struct ieee802154_dev *dev)
411 struct mrf24j40 *devrec = dev->priv;
414 dev_dbg(printdev(devrec), "stop\n");
416 ret = read_short_reg(devrec, REG_INTCON, &val);
419 val |= 0x1|0x8; /* Set TXNIE and RXIE. Disable Interrupts */
420 write_short_reg(devrec, REG_INTCON, val);
425 static int mrf24j40_set_channel(struct ieee802154_dev *dev,
426 int page, int channel)
428 struct mrf24j40 *devrec = dev->priv;
432 dev_dbg(printdev(devrec), "Set Channel %d\n", channel);
435 WARN_ON(channel < MRF24J40_CHAN_MIN);
436 WARN_ON(channel > MRF24J40_CHAN_MAX);
438 /* Set Channel TODO */
439 val = (channel-11) << 4 | 0x03;
440 write_long_reg(devrec, REG_RFCON0, val);
443 ret = read_short_reg(devrec, REG_RFCTL, &val);
447 write_short_reg(devrec, REG_RFCTL, val);
449 write_short_reg(devrec, REG_RFCTL, val);
451 udelay(SET_CHANNEL_DELAY_US); /* per datasheet */
456 static int mrf24j40_filter(struct ieee802154_dev *dev,
457 struct ieee802154_hw_addr_filt *filt,
458 unsigned long changed)
460 struct mrf24j40 *devrec = dev->priv;
462 dev_dbg(printdev(devrec), "filter\n");
464 if (changed & IEEE802515_AFILT_SADDR_CHANGED) {
467 addrh = filt->short_addr >> 8 & 0xff;
468 addrl = filt->short_addr & 0xff;
470 write_short_reg(devrec, REG_SADRH, addrh);
471 write_short_reg(devrec, REG_SADRL, addrl);
472 dev_dbg(printdev(devrec),
473 "Set short addr to %04hx\n", filt->short_addr);
476 if (changed & IEEE802515_AFILT_IEEEADDR_CHANGED) {
479 for (i = 0; i < 8; i++)
480 write_short_reg(devrec, REG_EADR0+i,
484 printk(KERN_DEBUG "Set long addr to: ");
485 for (i = 0; i < 8; i++)
486 printk("%02hhx ", filt->ieee_addr[i]);
487 printk(KERN_DEBUG "\n");
491 if (changed & IEEE802515_AFILT_PANID_CHANGED) {
494 panidh = filt->pan_id >> 8 & 0xff;
495 panidl = filt->pan_id & 0xff;
496 write_short_reg(devrec, REG_PANIDH, panidh);
497 write_short_reg(devrec, REG_PANIDL, panidl);
499 dev_dbg(printdev(devrec), "Set PANID to %04hx\n", filt->pan_id);
502 if (changed & IEEE802515_AFILT_PANC_CHANGED) {
503 /* Pan Coordinator */
507 ret = read_short_reg(devrec, REG_RXMCR, &val);
514 write_short_reg(devrec, REG_RXMCR, val);
516 /* REG_SLOTTED is maintained as default (unslotted/CSMA-CA).
517 * REG_ORDER is maintained as default (no beacon/superframe).
520 dev_dbg(printdev(devrec), "Set Pan Coord to %s\n",
521 filt->pan_coord ? "on" : "off");
527 static int mrf24j40_handle_rx(struct mrf24j40 *devrec)
529 u8 len = RX_FIFO_SIZE;
535 /* Turn off reception of packets off the air. This prevents the
536 * device from overwriting the buffer while we're reading it. */
537 ret = read_short_reg(devrec, REG_BBREG1, &val);
540 val |= 4; /* SET RXDECINV */
541 write_short_reg(devrec, REG_BBREG1, val);
543 skb = alloc_skb(len, GFP_KERNEL);
549 ret = mrf24j40_read_rx_buf(devrec, skb_put(skb, len), &len, &lqi);
551 dev_err(printdev(devrec), "Failure reading RX FIFO\n");
557 /* Cut off the checksum */
558 skb_trim(skb, len-2);
560 /* TODO: Other drivers call ieee20154_rx_irqsafe() here (eg: cc2040,
561 * also from a workqueue). I think irqsafe is not necessary here.
562 * Can someone confirm? */
563 ieee802154_rx_irqsafe(devrec->dev, skb, lqi);
565 dev_dbg(printdev(devrec), "RX Handled\n");
568 /* Turn back on reception of packets off the air. */
569 ret = read_short_reg(devrec, REG_BBREG1, &val);
572 val &= ~0x4; /* Clear RXDECINV */
573 write_short_reg(devrec, REG_BBREG1, val);
578 static struct ieee802154_ops mrf24j40_ops = {
579 .owner = THIS_MODULE,
582 .start = mrf24j40_start,
583 .stop = mrf24j40_stop,
584 .set_channel = mrf24j40_set_channel,
585 .set_hw_addr_filt = mrf24j40_filter,
588 static irqreturn_t mrf24j40_isr(int irq, void *data)
590 struct mrf24j40 *devrec = data;
592 disable_irq_nosync(irq);
594 schedule_work(&devrec->irqwork);
599 static void mrf24j40_isrwork(struct work_struct *work)
601 struct mrf24j40 *devrec = container_of(work, struct mrf24j40, irqwork);
605 /* Read the interrupt status */
606 ret = read_short_reg(devrec, REG_INTSTAT, &intstat);
610 /* Check for TX complete */
612 complete(&devrec->tx_complete);
616 mrf24j40_handle_rx(devrec);
619 enable_irq(devrec->spi->irq);
622 static int mrf24j40_probe(struct spi_device *spi)
626 struct mrf24j40 *devrec;
627 struct pinctrl *pinctrl;
629 printk(KERN_INFO "mrf24j40: probe(). IRQ: %d\n", spi->irq);
631 devrec = kzalloc(sizeof(struct mrf24j40), GFP_KERNEL);
634 devrec->buf = kzalloc(3, GFP_KERNEL);
638 pinctrl = devm_pinctrl_get_select_default(&spi->dev);
641 "pinctrl pins are not configured from the driver");
643 spi->mode = SPI_MODE_0; /* TODO: Is this appropriate for right here? */
644 if (spi->max_speed_hz > MAX_SPI_SPEED_HZ)
645 spi->max_speed_hz = MAX_SPI_SPEED_HZ;
647 mutex_init(&devrec->buffer_mutex);
648 init_completion(&devrec->tx_complete);
649 INIT_WORK(&devrec->irqwork, mrf24j40_isrwork);
651 dev_set_drvdata(&spi->dev, devrec);
653 /* Register with the 802154 subsystem */
655 devrec->dev = ieee802154_alloc_device(0, &mrf24j40_ops);
659 devrec->dev->priv = devrec;
660 devrec->dev->parent = &devrec->spi->dev;
661 devrec->dev->phy->channels_supported[0] = CHANNEL_MASK;
662 devrec->dev->flags = IEEE802154_HW_OMIT_CKSUM|IEEE802154_HW_AACK;
664 dev_dbg(printdev(devrec), "registered mrf24j40\n");
665 ret = ieee802154_register_device(devrec->dev);
667 goto err_register_device;
669 /* Initialize the device.
670 From datasheet section 3.2: Initialization. */
671 write_short_reg(devrec, REG_SOFTRST, 0x07);
672 write_short_reg(devrec, REG_PACON2, 0x98);
673 write_short_reg(devrec, REG_TXSTBL, 0x95);
674 write_long_reg(devrec, REG_RFCON0, 0x03);
675 write_long_reg(devrec, REG_RFCON1, 0x01);
676 write_long_reg(devrec, REG_RFCON2, 0x80);
677 write_long_reg(devrec, REG_RFCON6, 0x90);
678 write_long_reg(devrec, REG_RFCON7, 0x80);
679 write_long_reg(devrec, REG_RFCON8, 0x10);
680 write_long_reg(devrec, REG_SLPCON1, 0x21);
681 write_short_reg(devrec, REG_BBREG2, 0x80);
682 write_short_reg(devrec, REG_CCAEDTH, 0x60);
683 write_short_reg(devrec, REG_BBREG6, 0x40);
684 write_short_reg(devrec, REG_RFCTL, 0x04);
685 write_short_reg(devrec, REG_RFCTL, 0x0);
688 /* Set RX Mode. RXMCR<1:0>: 0x0 normal, 0x1 promisc, 0x2 error */
689 ret = read_short_reg(devrec, REG_RXMCR, &val);
692 val &= ~0x3; /* Clear RX mode (normal) */
693 write_short_reg(devrec, REG_RXMCR, val);
695 ret = request_irq(spi->irq,
697 IRQF_TRIGGER_FALLING,
702 dev_err(printdev(devrec), "Unable to get IRQ");
710 ieee802154_unregister_device(devrec->dev);
712 ieee802154_free_device(devrec->dev);
721 static int mrf24j40_remove(struct spi_device *spi)
723 struct mrf24j40 *devrec = dev_get_drvdata(&spi->dev);
725 dev_dbg(printdev(devrec), "remove\n");
727 free_irq(spi->irq, devrec);
728 flush_work(&devrec->irqwork); /* TODO: Is this the right call? */
729 ieee802154_unregister_device(devrec->dev);
730 ieee802154_free_device(devrec->dev);
731 /* TODO: Will ieee802154_free_device() wait until ->xmit() is
734 /* Clean up the SPI stuff. */
735 dev_set_drvdata(&spi->dev, NULL);
741 static const struct spi_device_id mrf24j40_ids[] = {
746 MODULE_DEVICE_TABLE(spi, mrf24j40_ids);
748 static struct spi_driver mrf24j40_driver = {
751 .bus = &spi_bus_type,
752 .owner = THIS_MODULE,
754 .id_table = mrf24j40_ids,
755 .probe = mrf24j40_probe,
756 .remove = mrf24j40_remove,
759 static int __init mrf24j40_init(void)
761 return spi_register_driver(&mrf24j40_driver);
764 static void __exit mrf24j40_exit(void)
766 spi_unregister_driver(&mrf24j40_driver);
769 module_init(mrf24j40_init);
770 module_exit(mrf24j40_exit);
772 MODULE_LICENSE("GPL");
773 MODULE_AUTHOR("Alan Ott");
774 MODULE_DESCRIPTION("MRF24J40 SPI 802.15.4 Controller Driver");