bcfserial.c

/*
 *  bcfserial.c - Serial interface driver for BeagleConnect Freedom.
 */
#include <linux/circ_buf.h>
#include <linux/crc-ccitt.h>
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/serdev.h>
#include <linux/sched.h>
#include <linux/skbuff.h>

#include <net/cfg802154.h>
#include <net/mac802154.h>

#define DEBUG

#define BCFSERIAL_DRV_VERSION "0.1.0"
#define BCFSERIAL_DRV_NAME "bcfserial"

#define HDLC_FRAME	0x7E
#define HDLC_ESC	0x7D
#define HDLC_XOR	0x20

#define ADDRESS_CTRL	0x01
#define ADDRESS_WPAN	0x03
#define ADDRESS_CDC	0x05
#define ADDRESS_HW	0x41

#define MAX_PSDU		127
#define MAX_RX_XFER		(1 + MAX_PSDU + 2 + 1)	/* PHR+PSDU+CRC+LQI */
#define HDLC_HEADER_LEN 	2
#define PACKET_HEADER_LEN	8
#define CRC_LEN 		2
#define RX_HDLC_PAYLOAD		140
#define MAX_TX_HDLC		(1 + HDLC_HEADER_LEN + PACKET_HEADER_LEN + MAX_RX_XFER + CRC_LEN + 1)
#define MAX_RX_HDLC		(1 + RX_HDLC_PAYLOAD + CRC_LEN)
#define TX_CIRC_BUF_SIZE	1024

enum bcfserial_requests {
	RESET,
	TX,
	XMIT_ASYNC,
	ED,
	SET_CHANNEL,
	START,
	STOP,
	SET_SHORT_ADDR,
	SET_PAN_ID,
	SET_IEEE_ADDR,
	SET_TXPOWER,
	SET_CCA_MODE,
	SET_CCA_ED_LEVEL,
	SET_CSMA_PARAMS,
	SET_LBT,
	SET_FRAME_RETRIES,
	SET_PROMISCUOUS_MODE,
	GET_EXTENDED_ADDR,
	GET_SUPPORTED_CHANNELS,
};

struct bcfserial {
	struct serdev_device *serdev;
	struct ieee802154_hw *hw;

	struct work_struct tx_work;
	spinlock_t tx_producer_lock;
	spinlock_t tx_consumer_lock;
	struct circ_buf tx_circ_buf;
	struct sk_buff *tx_skb;
	u16 tx_crc;
	u8 tx_ack_seq;		/* current TX ACK sequence number */

	size_t response_size;
	u8 *response_buffer;

	u8 rx_in_esc;
	u8 rx_address;
	u16 rx_offset;
	u8 *rx_buffer;
};

// RX Packet Format:
// - WPAN RX PACKET:	[len] payload [lqi]
// - WPAN TX ACK:	[seq]
// - WPAN CAPABILITIES:	supported_channels_mask(4)
// - CDC:		printable_chars

static void bcfserial_serdev_write_locked(struct bcfserial *bcfserial)
{
	//must be locked already
	int head = smp_load_acquire(&bcfserial->tx_circ_buf.head);
	int tail = bcfserial->tx_circ_buf.tail;
	int count = CIRC_CNT_TO_END(head, tail, TX_CIRC_BUF_SIZE);
	int written;

	if (count >= 1) {
		written = serdev_device_write_buf(bcfserial->serdev, &bcfserial->tx_circ_buf.buf[tail], count);

		smp_store_release(&(bcfserial->tx_circ_buf.tail), (tail + written) & (TX_CIRC_BUF_SIZE - 1));
	}
}

static void bcfserial_append(struct bcfserial *bcfserial, u8 value)
{
	//must be locked already
	int head = bcfserial->tx_circ_buf.head;

	while(true)
	{
		int tail = READ_ONCE(bcfserial->tx_circ_buf.tail);

		if (CIRC_SPACE(head, tail, TX_CIRC_BUF_SIZE) >= 1) {

			bcfserial->tx_circ_buf.buf[head] = value;

			smp_store_release(&(bcfserial->tx_circ_buf.head),
					  (head + 1) & (TX_CIRC_BUF_SIZE - 1));
			return;
		} else {
			dev_dbg(&bcfserial->serdev->dev, "Tx circ buf full\n");
			usleep_range(3000,5000);
		}
	}
}

static void bcfserial_append_tx_frame(struct bcfserial *bcfserial)
{
	bcfserial->tx_crc = 0xFFFF;
	bcfserial_append(bcfserial, HDLC_FRAME);
}

static void bcfserial_append_escaped(struct bcfserial *bcfserial, u8 value)
{
        if (value == HDLC_FRAME || value == HDLC_ESC) {
                bcfserial_append(bcfserial, HDLC_ESC);
                value ^= HDLC_XOR;
        }
        bcfserial_append(bcfserial, value);
}

static void bcfserial_append_tx_u8(struct bcfserial *bcfserial, u8 value)
{
	bcfserial->tx_crc = crc_ccitt(bcfserial->tx_crc, &value, 1);
	bcfserial_append_escaped(bcfserial, value);
}

static void bcfserial_append_tx_buffer(struct bcfserial *bcfserial, const void *buffer, size_t len)
{
	size_t i;
	for (i=0; i<len; i++) {
		bcfserial_append_tx_u8(bcfserial, ((u8*)buffer)[i]);
	}
}

static void bcfserial_append_tx_le16(struct bcfserial *bcfserial, u16 value)
{
	value = cpu_to_le16(value);
	bcfserial_append_tx_buffer(bcfserial, (u8 *)&value, sizeof(u16));
}

static void bcfserial_append_tx_crc(struct bcfserial *bcfserial)
{
	bcfserial->tx_crc ^= 0xffff;
	bcfserial_append_escaped(bcfserial, bcfserial->tx_crc & 0xff);
	bcfserial_append_escaped(bcfserial, (bcfserial->tx_crc >> 8) & 0xff);
}

static void bcfserial_hdlc_send(struct bcfserial *bcfserial, u8 cmd, u16 value, u16 index, u16 length, const void* buffer)
{
	// HDLC_FRAME
	// 0 address : 0x01
	// 1 control : 0x03
	// 2 [bmRequestType] : 0x00
	// 3 cmd (TX, START, STOP, etc)
	// 4/5 value
	// 6/7 index
	// 8/9 length
	// contents
	// x/y crc
	// HDLC_FRAME

	spin_lock(&bcfserial->tx_producer_lock);

	bcfserial_append_tx_frame(bcfserial);
	bcfserial_append_tx_u8(bcfserial, 0x01); //address
	bcfserial_append_tx_u8(bcfserial, 0x03); //control
	bcfserial_append_tx_u8(bcfserial, 0x00); //ignored
	bcfserial_append_tx_u8(bcfserial, cmd);
	bcfserial_append_tx_le16(bcfserial, value);
	bcfserial_append_tx_le16(bcfserial, index);
	bcfserial_append_tx_le16(bcfserial, length);
	bcfserial_append_tx_buffer(bcfserial, buffer, length);
	bcfserial_append_tx_crc(bcfserial);
	bcfserial_append_tx_frame(bcfserial);

	spin_unlock(&bcfserial->tx_producer_lock);

	spin_lock(&bcfserial->tx_consumer_lock);
	bcfserial_serdev_write_locked(bcfserial);
	spin_unlock(&bcfserial->tx_consumer_lock);
}

static void bcfserial_hdlc_send_cmd(struct bcfserial *bcfserial, u8 cmd)
{
	bcfserial_hdlc_send(bcfserial, cmd, 0, 0, 0, NULL);
}

static void bcfserial_hdlc_send_ack(struct bcfserial *bcfserial, u8 address, u8 seq)
{
	// To make this a valid S-frame:
	// u8 ctrl = (((seq + 1) & 0x07) << 5) | 0x01;
	// TODO Fix control frame type bug here and in wpanusb_bc

	spin_lock(&bcfserial->tx_producer_lock);

	bcfserial_append_tx_frame(bcfserial);
	bcfserial_append_tx_u8(bcfserial, address); //address
	bcfserial_append_tx_u8(bcfserial, 0x00); //control
	bcfserial_append_tx_crc(bcfserial);
	bcfserial_append_tx_frame(bcfserial);

	spin_unlock(&bcfserial->tx_producer_lock);

	spin_lock(&bcfserial->tx_consumer_lock);
	bcfserial_serdev_write_locked(bcfserial);
	spin_unlock(&bcfserial->tx_consumer_lock);
}

static int bcfserial_hdlc_receive(struct bcfserial *bcfserial, u8 cmd, void *buffer, size_t count)
{
	int retries = 5;
	bcfserial->response_size = count;
	bcfserial->response_buffer = (u8*)buffer;
	bcfserial_hdlc_send_cmd(bcfserial, cmd);
	// TODO semaphore? give/take 
	do {
		usleep_range(10000,10001);
	} while (bcfserial->response_size && retries--);
	bcfserial->response_buffer = NULL;
	if (bcfserial->response_size) {
		bcfserial->response_size = 0;
		return -EAGAIN;
	}
	return 0;
}

static int bcfserial_start(struct ieee802154_hw *hw)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "START\n");
	bcfserial_hdlc_send_cmd(bcfserial, START);
	return 0;
}

static void bcfserial_stop(struct ieee802154_hw *hw)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "STOP\n");
	bcfserial_hdlc_send_cmd(bcfserial, STOP);
}

static int bcfserial_xmit(struct ieee802154_hw *hw, struct sk_buff *skb)
{
	struct bcfserial *bcfserial = hw->priv;

	if (bcfserial->tx_skb)
	{
		dev_err(&bcfserial->serdev->dev, "SKB not freed! %d\n", bcfserial->tx_ack_seq);
	}

	bcfserial->tx_skb = skb;
	bcfserial->tx_ack_seq++;
	if (!bcfserial->tx_ack_seq) {
		bcfserial->tx_ack_seq++;
	}

	dev_dbg(&bcfserial->serdev->dev, "XMIT %02x %d\n", bcfserial->tx_ack_seq, skb->len);

	bcfserial_hdlc_send(bcfserial, TX, 0, bcfserial->tx_ack_seq, skb->len, skb->data);

	return 0;
}

static int bcfserial_ed(struct ieee802154_hw *hw, u8 *level)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "ED\n");
	WARN_ON(!level);
	*level = 0xbe;
	return 0;
}

static int bcfserial_set_channel(struct ieee802154_hw *hw, u8 page, u8 channel)
{
	struct bcfserial *bcfserial = hw->priv;
	u8 buffer[2] = {page, channel};
	dev_dbg(&bcfserial->serdev->dev, "SET CHANNEL %u %u\n", page, channel);
	bcfserial_hdlc_send(bcfserial, SET_CHANNEL, 0, 0, 2, &buffer);
	return 0;
}

static int bcfserial_set_hw_addr_filt(struct ieee802154_hw *hw,
				      struct ieee802154_hw_addr_filt *filt,
				      unsigned long changed)
{
	struct bcfserial *bcfserial = hw->priv;

	if (changed & IEEE802154_AFILT_SADDR_CHANGED) {
		u16 addr = le16_to_cpu(filt->short_addr);
		dev_dbg(&bcfserial->serdev->dev, "Short Address changed %x\n", addr);
		bcfserial_hdlc_send(bcfserial, SET_SHORT_ADDR, 0, 0, sizeof(addr), &addr);
	}

	if (changed & IEEE802154_AFILT_PANID_CHANGED) {
		u16 pan = le16_to_cpu(filt->pan_id);
		dev_dbg(&bcfserial->serdev->dev, "PAN ID changed %x\n", pan);
		bcfserial_hdlc_send(bcfserial, SET_PAN_ID, 0, 0, sizeof(pan), &pan);
	}

	if (changed & IEEE802154_AFILT_IEEEADDR_CHANGED) {
		u64 ieee_addr = le64_to_cpu(filt->ieee_addr);
		dev_dbg(&bcfserial->serdev->dev, "IEEE Addr changed %llx\n", ieee_addr);
		bcfserial_hdlc_send(bcfserial, SET_IEEE_ADDR, 0, 0, sizeof(ieee_addr), &ieee_addr);
	}
	return 0;
}

static int bcfserial_set_txpower(struct ieee802154_hw *hw, s32 mbm)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "SET TXPOWER\n");
	return -ENOTSUPP;
}

static int bcfserial_set_lbt(struct ieee802154_hw *hw, bool on)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "SET LBT\n");
	return -ENOTSUPP;
}

static int bcfserial_set_cca_mode(struct ieee802154_hw *hw,
			   const struct wpan_phy_cca *cca)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "SET CCA MODE\n");
	return -ENOTSUPP;
}

static int bcfserial_set_cca_ed_level(struct ieee802154_hw *hw, s32 mbm)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "SET CCA ED LEVEL\n");
	return -ENOTSUPP;
}

static int bcfserial_set_csma_params(struct ieee802154_hw *hw, u8 min_be, u8 max_be,
			      u8 retries)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "SET CSMA PARAMS\n");
	return -ENOTSUPP;
}

static int bcfserial_set_frame_retries(struct ieee802154_hw *hw, s8 retries)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "SET FRAME RETRIES\n");
	return -ENOTSUPP;
}

static int bcfserial_set_promiscuous_mode(struct ieee802154_hw *hw, const bool on)
{
	struct bcfserial *bcfserial = hw->priv;
	dev_dbg(&bcfserial->serdev->dev, "SET PROMISCUOUS\n");
	return -ENOTSUPP;
}

static const struct ieee802154_ops bcfserial_ops = {
	.owner			= THIS_MODULE,
	.start			= bcfserial_start,
	.stop			= bcfserial_stop,
	.xmit_async		= bcfserial_xmit,
	.ed			= bcfserial_ed,
	.set_channel		= bcfserial_set_channel,
	.set_hw_addr_filt	= bcfserial_set_hw_addr_filt,
	.set_txpower		= bcfserial_set_txpower,
	.set_lbt		= bcfserial_set_lbt,
	.set_cca_mode		= bcfserial_set_cca_mode,
	.set_cca_ed_level	= bcfserial_set_cca_ed_level,
	.set_csma_params	= bcfserial_set_csma_params,
	.set_frame_retries	= bcfserial_set_frame_retries,
	.set_promiscuous_mode	= bcfserial_set_promiscuous_mode,
};

static void bcfserial_wpan_rx(struct bcfserial *bcfserial, const u8 *buffer, size_t count)
{
	struct sk_buff *skb;
	u8 len, lqi;

	if (count == 1) {
		// TX ACK
		dev_dbg(&bcfserial->serdev->dev, "TX ACK: 0x%02x:0x%02x\n", buffer[0], bcfserial->tx_ack_seq);

		if (buffer[0] == bcfserial->tx_ack_seq && bcfserial->tx_skb) {
			skb = bcfserial->tx_skb;
			bcfserial->tx_skb = NULL;
			ieee802154_xmit_complete(bcfserial->hw, skb, false);
		} else {
			dev_err(&bcfserial->serdev->dev, "unknown ack %u\n", bcfserial->tx_ack_seq);
		}
	} else if (bcfserial->response_size == count && bcfserial->response_buffer) {
		//TODO replace with semaphore
		dev_dbg(&bcfserial->serdev->dev, "Response size %u found\n", count);
		memcpy(bcfserial->response_buffer, buffer, count);
		bcfserial->response_size = 0;
	} else {
		// RX Packet
		dev_dbg(&bcfserial->serdev->dev, "RX Packet Len:%u LQI:%u\n", buffer[0], buffer[count-1]);
		len = buffer[0];
		lqi = buffer[count-1];

		if (len+2 != count) {
			dev_err(&bcfserial->serdev->dev, "RX Packet invalid length\n");
			return;
		}

		if (!ieee802154_is_valid_psdu_len(len)) {
			dev_err(&bcfserial->serdev->dev, "frame corrupted\n");
			return;
		}

		skb = dev_alloc_skb(IEEE802154_MTU);
		if (!skb) {
			dev_err(&bcfserial->serdev->dev, "failed to allocate sk_buff\n");
			return;
		}

		skb_put_data(skb, buffer+1, len);
		ieee802154_rx_irqsafe(bcfserial->hw, skb, lqi);
	}
}

static int bcfserial_tty_receive(struct serdev_device *serdev,
	const unsigned char *data, size_t count)
{
	struct bcfserial *bcfserial = serdev_device_get_drvdata(serdev);
	u16 crc_check = 0;
	size_t i;
	u8 c;


	for (i = 0; i < count; i++) {
		c = data[i];

		if (c == HDLC_FRAME) {
			if (bcfserial->rx_address != 0xFF) {
				crc_check = crc_ccitt(0xffff, &bcfserial->rx_address, 1);
				crc_check = crc_ccitt(crc_check, bcfserial->rx_buffer, bcfserial->rx_offset);

				if (crc_check == 0xf0b8) {
					if ((bcfserial->rx_buffer[0] & 1) == 0) {
						//I-Frame, send S-Frame ACK
						bcfserial_hdlc_send_ack(bcfserial, bcfserial->rx_address, (bcfserial->rx_buffer[0] >> 1) & 0x7);
					}

					if (bcfserial->rx_address == ADDRESS_WPAN) {
						bcfserial_wpan_rx(bcfserial, bcfserial->rx_buffer + 1, bcfserial->rx_offset - 3);
					}
					else if (bcfserial->rx_address == ADDRESS_CDC) {
						bcfserial->rx_buffer[bcfserial->rx_offset-2] = 0;
						printk("> %s", bcfserial->rx_buffer+1);
					}
				}
				else {
					dev_err(&bcfserial->serdev->dev, "CRC Failed from %02x: 0x%04x\n", bcfserial->rx_address, crc_check);
				}
			}
			bcfserial->rx_offset = 0;
			bcfserial->rx_address = 0xFF;
		} else if (c == HDLC_ESC) {
			bcfserial->rx_in_esc = 1;
		} else {
			if (bcfserial->rx_in_esc) {
				c ^= 0x20;
				bcfserial->rx_in_esc = 0;
			}

			if (bcfserial->rx_address == 0xFF) {
				bcfserial->rx_address = c;
				if (bcfserial->rx_address == ADDRESS_WPAN ||
				   bcfserial->rx_address == ADDRESS_CDC ||
				   bcfserial->rx_address == ADDRESS_HW) {
				} else {
					bcfserial->rx_address = 0xFF;
				}
					bcfserial->rx_offset = 0;
			} else {
				if (bcfserial->rx_offset < MAX_RX_HDLC) {
					bcfserial->rx_buffer[bcfserial->rx_offset] = c;
					bcfserial->rx_offset++;
				} else {
					//buffer overflow
					dev_err(&bcfserial->serdev->dev, "RX Buffer Overflow\n");
					bcfserial->rx_address = 0xFF;
					bcfserial->rx_offset = 0;
				}
			}
		}
	}

	return count;
}

static void bcfserial_uart_transmit(struct work_struct *work)
{
	struct bcfserial *bcfserial = container_of(work, struct bcfserial, tx_work);

	spin_lock_bh(&bcfserial->tx_consumer_lock);
	bcfserial_serdev_write_locked(bcfserial);
	spin_unlock_bh(&bcfserial->tx_consumer_lock);
}

static void bcfserial_tty_wakeup(struct serdev_device *serdev)
{
	struct bcfserial *bcfserial = serdev_device_get_drvdata(serdev);

	schedule_work(&bcfserial->tx_work);
}

static struct serdev_device_ops bcfserial_serdev_ops = {
	.receive_buf = bcfserial_tty_receive,
	.write_wakeup = bcfserial_tty_wakeup,
};

static const struct of_device_id bcfserial_of_match[] = {
	{
	.compatible = "beagle,bcfserial",
	},
	{}
};
MODULE_DEVICE_TABLE(of, bcfserial_of_match);

static const s32 channel_powers[] = {
	300, 280, 230, 180, 130, 70, 0, -100, -200, -300, -400, -500, -700,
	-900, -1200, -1700,
};

static int bcfserial_get_device_capabilities(struct bcfserial *bcfserial)
{
	u32 valid_channels = 0;
	int ret = 0;
	struct ieee802154_hw *hw = bcfserial->hw;

	bcfserial_hdlc_send_cmd(bcfserial, RESET);

	ret = bcfserial_hdlc_receive(bcfserial, GET_SUPPORTED_CHANNELS, &valid_channels, sizeof(valid_channels));
	if (ret < 0) {
		return ret;
	}
	dev_dbg(&bcfserial->serdev->dev, "Supported Channels %x\n", valid_channels);

	/* FIXME: these need to come from device capabilities */
	hw->flags = IEEE802154_HW_TX_OMIT_CKSUM | IEEE802154_HW_AFILT;

	/* FIXME: these need to come from device capabilities */
	hw->phy->flags = WPAN_PHY_FLAG_TXPOWER;

	/* Set default and supported channels */
	hw->phy->current_page = 0;
	hw->phy->current_channel = ffs(valid_channels) - 1; //set to lowest valid channel
	hw->phy->supported.channels[0] = valid_channels;

	/* FIXME: these need to come from device capabilities */
	hw->phy->supported.tx_powers = channel_powers;
	hw->phy->supported.tx_powers_size = ARRAY_SIZE(channel_powers);
	hw->phy->transmit_power = hw->phy->supported.tx_powers[0];

	return ret;
}

static int bcfserial_probe(struct serdev_device *serdev)
{
	struct ieee802154_hw *hw;
	struct bcfserial *bcfserial = NULL;
	u32 speed = 115200;
	int ret;

	hw = ieee802154_alloc_hw(sizeof(struct bcfserial), &bcfserial_ops);
	if (!hw)
		return -ENOMEM;

	bcfserial = hw->priv;
	bcfserial->hw = hw;
	hw->parent = &serdev->dev;
	bcfserial->serdev = serdev;

	INIT_WORK(&bcfserial->tx_work, bcfserial_uart_transmit);

	spin_lock_init(&bcfserial->tx_producer_lock);
	spin_lock_init(&bcfserial->tx_consumer_lock);
	bcfserial->tx_circ_buf.head = 0;
	bcfserial->tx_circ_buf.tail = 0;
	bcfserial->tx_circ_buf.buf = devm_kmalloc(&serdev->dev, TX_CIRC_BUF_SIZE, GFP_KERNEL);

	bcfserial->rx_buffer = devm_kmalloc(&serdev->dev, MAX_RX_HDLC, GFP_KERNEL);
	bcfserial->rx_offset = 0;
	bcfserial->rx_address = 0xff;
	bcfserial->rx_in_esc = 0;

	serdev_device_set_drvdata(serdev, bcfserial);
	serdev_device_set_client_ops(serdev, &bcfserial_serdev_ops);

	ret = serdev_device_open(serdev);
	if (ret) {
		dev_err(&bcfserial->serdev->dev, "Unable to open device\n");
		goto fail_hw;
	}

	speed = serdev_device_set_baudrate(serdev, speed);
	dev_dbg(&bcfserial->serdev->dev, "Using baudrate %u\n", speed);

	serdev_device_set_flow_control(serdev, false);

	bcfserial_hdlc_send_ack(bcfserial, 0x41, 0x00);

	ret = bcfserial_get_device_capabilities(bcfserial);

	if (ret < 0) {
		// dev_err(&udev->dev, "Failed to get device capabilities");
		dev_err(&bcfserial->serdev->dev, "Failed to get device capabilities\n");
		goto fail;
	}

	ret = ieee802154_register_hw(hw);

	dev_info(&bcfserial->serdev->dev, "bcfserial started");
	if (ret)
		goto fail;

	return 0;

fail:
	dev_err(&bcfserial->serdev->dev, "Closing serial device on failure\n");
	serdev_device_close(serdev);
fail_hw:
	printk(KERN_ERR "Failed to open bcfserial\n");
	ieee802154_free_hw(hw);
	return ret;
}

static void bcfserial_remove(struct serdev_device *serdev)
{
	struct bcfserial *bcfserial = serdev_device_get_drvdata(serdev);
	dev_info(&bcfserial->serdev->dev, "Closing serial device\n");
	ieee802154_unregister_hw(bcfserial->hw);
	flush_work(&bcfserial->tx_work);
	ieee802154_free_hw(bcfserial->hw);
	serdev_device_close(serdev);
}

static struct serdev_device_driver bcfserial_driver = {
	.probe = bcfserial_probe,
	.remove = bcfserial_remove,
	.driver = {
		.name = BCFSERIAL_DRV_NAME,
		.of_match_table = of_match_ptr(bcfserial_of_match),
	},
};

module_serdev_device_driver(bcfserial_driver);

MODULE_DESCRIPTION("WPAN serial driver for BeagleConnect Freedom");
MODULE_AUTHOR("Erik Larson <erik@statropy.com>");
MODULE_VERSION("0.1.0");
MODULE_LICENSE("GPL v2");