File 0001-Add-Osmocom-icE1usb-driver.patch of Package dahdi-linux

Overview Repositories Revisions Requests Users Attributes Meta

File 0001-Add-Osmocom-icE1usb-driver.patch of Package dahdi-linux (Revision 2709b2bb561c793e2a1bfda703339f23)

Currently displaying revision 2709b2bb561c793e2a1bfda703339f23 , Show latest

From f678761b2d1302f318aff3d496861325901adb11 Mon Sep 17 00:00:00 2001
From: Harald Welte <laforge@osmocom.org>
Date: Sat, 26 Dec 2020 14:20:53 +0100
Subject: [PATCH] Add Osmocom icE1usb driver

The Osmocom icE1usb is a modern, software-defined open hardware and
open source firmware design for a USB E1 interface.  You can find more
information at https://osmocom.org/projects/e1-t1-adapter/wiki/IcE1usb

The hardware design can be found at https://git.osmocom.org/osmo-e1-hardware

The FPGA gateware and associated embedded firmware is hosted in the same
git repository. Some parts are in submodules (be sure to use recursive
clone)

This DAHDI driver allows t lothe use of the icE1usb just like any other
E1/PRI interface device supported by DAHDI.  When using this DAHDI
driver, osmo-e1d most not be used.  The DAHDI driver is a replacement /
alternative for osmo-e1d.
---
 drivers/dahdi/Kbuild                  |   4 +
 drivers/dahdi/Kconfig                 |  13 +
 drivers/dahdi/icE1usb/Kbuild          |   1 +
 drivers/dahdi/icE1usb/icE1usb.c       | 992 ++++++++++++++++++++++++++
 drivers/dahdi/icE1usb/ice1usb_proto.h |  99 +++
 5 files changed, 1109 insertions(+)
 create mode 100644 drivers/dahdi/icE1usb/Kbuild
 create mode 100644 drivers/dahdi/icE1usb/icE1usb.c
 create mode 100644 drivers/dahdi/icE1usb/ice1usb_proto.h

diff --git a/drivers/dahdi/Kbuild b/drivers/dahdi/Kbuild
index ea936a8..958e070 100644
--- a/drivers/dahdi/Kbuild
+++ b/drivers/dahdi/Kbuild
@@ -6,6 +6,10 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_DYNAMIC_ETH)	+= dahdi_dynamic_eth.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_DYNAMIC_ETHMF)	+= dahdi_dynamic_ethmf.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_TRANSCODE)		+= dahdi_transcode.o
 
+ifdef CONFIG_USB
+obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_ICE1USB)		+= icE1usb/
+endif
+
 ifdef CONFIG_PCI
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_OCT612X)		+= oct612x/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCT4XXP)		+= wct4xxp/
diff --git a/drivers/dahdi/Kconfig b/drivers/dahdi/Kconfig
index 11d342c..18b5612 100644
--- a/drivers/dahdi/Kconfig
+++ b/drivers/dahdi/Kconfig
@@ -250,4 +250,17 @@ config DAHDI_WCTE11XP
 
 	  If unsure, say Y.
 
+config DAHDI_ICE1USB
+	tristate "Osmocom iceE1usb dual-E1 Support"
+	depends on DAHDI && USB
+	default DAHDI
+	---help---
+	  This driver provides support for the Osmocom icE1usb product.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called icE1usb.
+
+	  If unsure, say Y.
+
+
 source "drivers/dahdi/xpp/Kconfig"
diff --git a/drivers/dahdi/icE1usb/Kbuild b/drivers/dahdi/icE1usb/Kbuild
new file mode 100644
index 0000000..a97e916
--- /dev/null
+++ b/drivers/dahdi/icE1usb/Kbuild
@@ -0,0 +1 @@
+obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_ICE1USB) += icE1usb.o
diff --git a/drivers/dahdi/icE1usb/icE1usb.c b/drivers/dahdi/icE1usb/icE1usb.c
new file mode 100644
index 0000000..8cb1d12
--- /dev/null
+++ b/drivers/dahdi/icE1usb/icE1usb.c
@@ -0,0 +1,992 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+/* Osmocom icE1usb driver
+ * Copyright (C) 2020 by Harald Welte <laforge@osmocom.org>
+ * inspired by osmo-e1d by Sylvain Munaut */
+
+/*  The Osmocom icE1usb is a modern, software-defined open hardware and
+    open source firmware design for a USB E1 interface.  You can find more
+    information at https://osmocom.org/projects/e1-t1-adapter/wiki/IcE1usb
+
+    The hardware design can be found at https://git.osmocom.org/osmo-e1-hardware
+
+    The FPGA gateware and associated embedded firmware is hosted in the same
+    git repository. Some parts are in submodules (be sure to use recursive
+    clone)
+
+    This DAHDI driver allows the use of the icE1usb just like any other
+    E1/PRI interface device supported by DAHDI.  When using this DAHDI
+    driver, osmo-e1d most not be used.  The DAHDI driver is a replacement /
+    alternative for osmo-e1d.
+
+*/
+
+#define DEBUG
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/usb.h>
+#include <linux/slab.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/pm_runtime.h>
+
+#include <dahdi/kernel.h>
+
+#include "ice1usb_proto.h"
+
+#define VERSION "0.1"
+
+/* number of isochronous frames per URB */
+#define ICE1USB_MAX_ISOC_FRAMES 	4
+
+/* number of URBs per endpoint */
+#define ICE1USB_NUM_URBS 	4
+
+#define ieu_dbg(x, fmt, args ...) \
+	dev_dbg(&((x)->usb_intf->dev), fmt, ## args)
+#define ieu_info(x, fmt, args ...) \
+	dev_info(&((x)->usb_intf->dev), fmt, ## args)
+#define ieu_warn(x, fmt, args ...) \
+	dev_warn(&((x)->usb_intf->dev), fmt, ## args)
+#define ieu_err(x, fmt, args ...) \
+	dev_err(&((x)->usb_intf->dev), fmt, ## args)
+
+/***********************************************************************
+* data structures
+***********************************************************************/
+
+enum ice1usb_flags {
+	ICE1USB_ISOC_RUNNING,
+	ICE1USB_IRQ_RUNNING,
+};
+
+struct ice1usb {
+	/* USB device and interface we operate on */
+	struct usb_device *usb_dev;
+	struct usb_interface *usb_intf;
+	/* altsetting for 'OFF' state */
+	const struct usb_host_interface *alt_off;
+	/* altsetting for 'ON' state */
+	const struct usb_host_interface *alt_on;
+	struct {
+		struct usb_anchor iso_in;
+		struct usb_anchor iso_out;
+		struct usb_anchor iso_fb;
+		struct usb_anchor irq;
+	} anchor;
+	/* USB endpoint numbers */
+	struct {
+		const struct usb_endpoint_descriptor *iso_in;
+		const struct usb_endpoint_descriptor *iso_out;
+		const struct usb_endpoint_descriptor *iso_fb;
+		const struct usb_endpoint_descriptor *irq;
+	} ep;
+	/* enum ice1usb_flags */
+	unsigned long flags;
+	/* feedback flow-control */
+	struct {
+		uint32_t r_acc;
+		uint32_t r_sw;
+	} fc;
+	/* DAHDI driver related bits */
+	struct {
+		struct dahdi_device *dev;
+		struct dahdi_span span;
+		struct dahdi_chan *chans[31];
+		/* [next rx byte] offset into chan[i]->readchunk */
+		unsigned int readchunk_idx;
+		/* [next tx byte] offset into chan[i]->writechunk */
+		unsigned int writechunk_idx;
+	} dahdi;
+	/* is the device still present (true) or already absent/unplugged (false) */
+	bool present;
+	/* spinlock protecting concurrent access to fc, {read,write}chunk_idx, ... */
+	spinlock_t lock;
+	/* maximum number of 32-byte E1 frames to send in one ISO OUT packet */
+	unsigned int max_fts;
+};
+
+static void ice1usb_free(struct ice1usb *ieu)
+{
+	usb_put_dev(ieu->usb_dev);
+	kfree(ieu);
+}
+
+static void e1u_free_channels(struct ice1usb *ieu)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(ieu->dahdi.chans); i++) {
+		kfree(ieu->dahdi.chans[i]);
+		ieu->dahdi.chans[i] = NULL;
+	}
+}
+
+static int e1u_alloc_channels(struct ice1usb *ieu)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(ieu->dahdi.chans); i++) {
+		struct dahdi_chan *chan;
+		kfree(ieu->dahdi.chans[i]);
+		chan = ieu->dahdi.chans[i] = kzalloc(sizeof(*chan), GFP_KERNEL);
+		if (!chan) {
+			e1u_free_channels(ieu);
+			return -ENOMEM;
+		}
+
+		chan->pvt = ieu;
+		snprintf(chan->name, sizeof(chan->name)-1, "%s/%d",
+			 ieu->dahdi.span.name, i+1);
+		chan->chanpos = i+1;
+		chan->sigcap = DAHDI_SIG_CLEAR | DAHDI_SIG_MTP2 | DAHDI_SIG_SF;
+	}
+	return 0;
+}
+
+/***********************************************************************
+ * ISOCHRONOUS transfers
+ ***********************************************************************/
+
+static inline void __fill_isoc_descriptor(struct urb *urb, unsigned int max_pack_size)
+{
+	unsigned int i, offset = 0;
+
+	for (i = 0; i < ICE1USB_MAX_ISOC_FRAMES; i++) {
+		urb->iso_frame_desc[i].offset = offset;
+		urb->iso_frame_desc[i].length = max_pack_size;
+		offset += max_pack_size;
+	};
+	urb->number_of_packets = i;
+}
+
+/* allocate + submit an isochronous URB for given EP; anchor it */
+static int ice1usb_submit_isoc_urb(struct ice1usb *ieu,
+				   const struct usb_endpoint_descriptor *ep,
+				   struct usb_anchor *anchor,
+				   usb_complete_t compl, gfp_t mem_flags)
+{
+	unsigned int max_pack_size = le16_to_cpu(ep->wMaxPacketSize);
+	unsigned int pipe, size, rc;
+	struct urb *urb;
+	uint8_t *buf;
+
+	urb = usb_alloc_urb(ICE1USB_MAX_ISOC_FRAMES, mem_flags);
+	if (!urb)
+		return -ENOMEM;
+
+	size = max_pack_size * ICE1USB_MAX_ISOC_FRAMES;
+	buf = kmalloc(size, mem_flags);
+	if (!buf) {
+		usb_free_urb(urb);
+		return -ENOMEM;
+	}
+
+	if (ep->bEndpointAddress & USB_DIR_IN)
+		pipe = usb_rcvisocpipe(ieu->usb_dev, ep->bEndpointAddress);
+	else
+		pipe = usb_sndisocpipe(ieu->usb_dev, ep->bEndpointAddress);
+
+	usb_fill_int_urb(urb, ieu->usb_dev, pipe, buf, size, compl, ieu,
+			 ep->bInterval);
+	urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
+
+	__fill_isoc_descriptor(urb, max_pack_size);
+
+	usb_anchor_urb(urb, anchor);
+
+	rc = usb_submit_urb(urb, mem_flags);
+	if (rc < 0) {
+		/* -EPERM: urb is being killed; -ENODEV: device got disconnected */
+		if (rc != -EPERM && rc != -ENODEV && rc != -ENOENT)
+			ieu_err(ieu, "EP 0x%02x urb %p submission failed (%d)",
+				ep->bEndpointAddress, urb, -rc);
+		usb_unanchor_urb(urb);
+	}
+
+	/* automatically free the URB (and its transfer buffer) once complete */
+	usb_free_urb(urb);
+
+	return rc;
+}
+
+/* process one incoming E1 frame (32 bytes; one for each TS) */
+static void _span_demux_one_frame(struct ice1usb *ieu, const uint8_t *data)
+{
+	struct dahdi_span *dspan = &ieu->dahdi.span;
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(ieu->dahdi.chans); i++) {
+		struct dahdi_chan *chan = ieu->dahdi.chans[i];
+		chan->readchunk[ieu->dahdi.readchunk_idx] = data[1+i];
+	}
+	ieu->dahdi.readchunk_idx++;
+
+	/* DAHDI_CHUNKSIZE is 8, meaning every channel (timeslot) wants data for 8
+ 	 * bytes (PCM samples) every time _dahdi_receive() is called */
+	if (ieu->dahdi.readchunk_idx == DAHDI_CHUNKSIZE) {
+		_dahdi_receive(dspan);
+		ieu->dahdi.readchunk_idx = 0;
+	}
+}
+
+/* IN endpoint URB completes */
+static void iso_in_complete(struct urb *urb)
+{
+	struct ice1usb *ieu = urb->context;
+	unsigned int i;
+	int rc;
+
+	//ieu_dbg(ieu, "IN urb %p completion (%d)", urb, urb->status);
+
+	switch (urb->status) {
+	case 0:
+		for (i = 0; i < urb->number_of_packets; i++) {
+			unsigned int offset = urb->iso_frame_desc[i].offset;
+			unsigned int length = urb->iso_frame_desc[i].actual_length;
+			unsigned long flags;
+			unsigned int j;
+
+			if (urb->iso_frame_desc[i].status) {
+				ieu_err(ieu, "IN urb %p frame %u status %d",
+					urb, i, urb->iso_frame_desc[i].status);
+				continue;
+			}
+
+			/* process received data */
+			spin_lock_irqsave(&ieu->lock, flags);
+			for (j = 4; j < length; j += 32)
+				_span_demux_one_frame(ieu, urb->transfer_buffer + offset + j);
+			spin_unlock_irqrestore(&ieu->lock, flags);
+		}
+		break;
+	case -ENOENT:
+	case -ESHUTDOWN:
+		/* Avoid suspend failed when usb_kill_urb */
+		return;
+	default:
+		ieu_err(ieu, "IN urb %p completion (%d)", urb, urb->status);
+		break;
+	}
+
+	/* re-submit unless stopped */
+	if (!test_bit(ICE1USB_ISOC_RUNNING, &ieu->flags))
+		return;
+
+	usb_anchor_urb(urb, &ieu->anchor.iso_in);
+	usb_mark_last_busy(ieu->usb_dev);
+
+	rc = usb_submit_urb(urb, GFP_ATOMIC);
+	if (rc < 0) {
+		/* -EPERM: urb is being killed; -ENODEV: device got disconnected */
+		if (rc != -EPERM && rc != -ENODEV && rc != -ENOENT)
+			ieu_err(ieu, "IN urb %p submission failed (%d)", urb, -rc);
+		usb_unanchor_urb(urb);
+	}
+}
+
+/* Feedback endpoint URB completes */
+static void iso_fb_complete(struct urb *urb)
+{
+	struct ice1usb *ieu = urb->context;
+	unsigned int i;
+	int rc;
+
+	//ieu_dbg(ieu, "FB urb %p completion (%d)", urb, urb->status);
+
+	switch (urb->status) {
+	case 0:
+		for (i = 0; i < urb->number_of_packets; i++) {
+			unsigned int offset = urb->iso_frame_desc[i].offset;
+			unsigned int length = urb->iso_frame_desc[i].actual_length;
+			const uint8_t *rx = urb->transfer_buffer + offset;
+			unsigned long flags;
+
+			if (urb->iso_frame_desc[i].status) {
+				ieu_err(ieu, "FB urb %p frame %u status %d",
+					urb, i, urb->iso_frame_desc[i].status);
+			}
+
+			if (urb->iso_frame_desc[i].status || length < 3)
+				continue;
+
+			/* process received data */
+			spin_lock_irqsave(&ieu->lock, flags);
+			ieu->fc.r_sw = (rx[2] << 16) | (rx[1] << 8) | rx[0];
+			spin_unlock_irqrestore(&ieu->lock, flags);
+		}
+		break;
+	case -ENOENT:
+	case -ESHUTDOWN:
+		/* Avoid suspend failed when usb_kill_urb */
+		return;
+	default:
+		ieu_err(ieu, "FB urb %p completion (%d)", urb, urb->status);
+		break;
+	}
+
+	/* re-submit unless stopped */
+	if (!test_bit(ICE1USB_ISOC_RUNNING, &ieu->flags))
+		return;
+
+	usb_anchor_urb(urb, &ieu->anchor.iso_fb);
+	usb_mark_last_busy(ieu->usb_dev);
+
+	rc = usb_submit_urb(urb, GFP_ATOMIC);
+	if (rc < 0) {
+		/* -EPERM: urb is being killed; -ENODEV: device got disconnected */
+		if (rc != -EPERM && rc != -ENODEV && rc != -ENOENT)
+			dev_err(&ieu->usb_dev->dev, "FB urb %p submission failed (%d)", urb, -rc);
+		usb_unanchor_urb(urb);
+	}
+}
+
+/* multiplex one E1 frame (32 bytes) and write it to 'out'; caller must hold ieu->lock */
+static void _span_mux_one_frame(struct ice1usb *ieu, uint8_t *out)
+{
+	struct dahdi_span *dspan = &ieu->dahdi.span;
+	unsigned int i;
+
+	out[0] = 0;
+
+	for (i = 0; i < ARRAY_SIZE(ieu->dahdi.chans); i++) {
+		struct dahdi_chan *chan = ieu->dahdi.chans[i];
+		out[1+i] = chan->writechunk[ieu->dahdi.writechunk_idx];
+	}
+	ieu->dahdi.writechunk_idx++;
+
+	/* DAHDI_CHUNKSIZE is 8, meaning every channel (timeslot) wants data for 8
+	 * bytes (PCM samples) every time _dahdi_receive() is called */
+	if (ieu->dahdi.writechunk_idx == DAHDI_CHUNKSIZE) {
+		_dahdi_transmit(dspan);
+		ieu->dahdi.writechunk_idx = 0;
+	}
+}
+
+/* OUT endpoint URB completes */
+static void iso_out_complete(struct urb *urb)
+{
+	struct ice1usb *ieu = urb->context;
+	unsigned int i, j;
+	int rc;
+
+	//ieu_dbg(ieu, "OUT urb %p completion (%d) %d", urb, urb->status, urb->number_of_packets);
+
+	switch (urb->status) {
+	case 0:
+		for (i = 0; i < urb->number_of_packets; i++) {
+			unsigned int offset = urb->iso_frame_desc[i].offset;
+			uint8_t *tx = urb->transfer_buffer + offset;
+			unsigned int fts; // frames to send
+			unsigned long flags;
+
+			if (urb->iso_frame_desc[i].status) {
+				ieu_err(ieu, "OUT urb %p frame %u status %d",
+					urb, i, urb->iso_frame_desc[i].status);
+			}
+
+
+			spin_lock_irqsave(&ieu->lock, flags);
+
+			/* flow control */
+			ieu->fc.r_acc += ieu->fc.r_sw;
+			fts = ieu->fc.r_acc >> 10;
+			if (fts < 4)
+				fts = 4;
+			else if (fts > ieu->max_fts)
+				fts = ieu->max_fts;
+
+			ieu->fc.r_acc -= fts << 10;
+			if (ieu->fc.r_acc & 0x80000000)
+				ieu->fc.r_acc = 0;
+
+			for (j = 0; j < fts; j++)
+				_span_mux_one_frame(ieu, tx + 4 + j*32);
+
+			spin_unlock_irqrestore(&ieu->lock, flags);
+
+			urb->iso_frame_desc[i].length = 4 + fts * 32;
+		}
+		break;
+	case -ENOENT:
+	case -ESHUTDOWN:
+		/* Avoid suspend failed when usb_kill_urb */
+		return;
+	default:
+		ieu_err(ieu, "OUT urb %p completion (%d)", urb, urb->status);
+		break;
+	}
+
+	/* re-submit unless stopped */
+	if (!test_bit(ICE1USB_ISOC_RUNNING, &ieu->flags))
+		return;
+
+	usb_anchor_urb(urb, &ieu->anchor.iso_out);
+	usb_mark_last_busy(ieu->usb_dev);
+
+	rc = usb_submit_urb(urb, GFP_ATOMIC);
+	if (rc < 0) {
+		/* -EPERM: urb is being killed; -ENODEV: device got disconnected */
+		if (rc != -EPERM && rc != -ENODEV && rc != -ENOENT)
+			ieu_err(ieu, "OUT urb %p submission failed (%d)", urb, -rc);
+		usb_unanchor_urb(urb);
+	}
+}
+
+/***********************************************************************
+ * INTERRUPT transfers
+ ***********************************************************************/
+
+/* interrupt EP completes: Process and resubmit */
+static void ice1usb_irq_complete(struct urb *urb)
+{
+	const struct ice1usb_irq *irq;
+	struct ice1usb *ieu = urb->context;
+	int rc;
+
+	//ieu_dbg(ieu, "IRQ urb %p completion (%d)", urb, urb->status);
+
+	if (urb->status == 0 && urb->actual_length >= sizeof(*irq)) {
+		const struct ice1usb_irq_err *err;
+		irq = (struct ice1usb_irq *) urb->transfer_buffer;
+		switch (irq->type) {
+		case ICE1USB_IRQQ_T_ERRCNT:
+			err = &irq->u.errors;
+			ieu_dbg(ieu, "IRQ: crc=%u, align=%u, ovfl=%u, unfl=%u, flags=%x",
+				le16_to_cpu(err->crc), le16_to_cpu(err->align),
+				le16_to_cpu(err->ovfl), le16_to_cpu(err->unfl), err->flags);
+			break;
+		}
+	} else if (urb->status == -ENOENT) {
+		/* Avoid suspend failed when usb_kill_urb */
+		return;
+	} else
+		ieu_err(ieu, "IRQ urb %p completion (%d)", urb, urb->status);
+
+	/* re-submit unless stopped */
+	if (!test_bit(ICE1USB_IRQ_RUNNING, &ieu->flags))
+		return;
+
+	usb_anchor_urb(urb, &ieu->anchor.irq);
+	usb_mark_last_busy(ieu->usb_dev);
+
+	rc = usb_submit_urb(urb, GFP_ATOMIC);
+	if (rc < 0) {
+		/* -EPERM: urb is being killed; -ENODEV: device got disconnected */
+		if (rc != -EPERM && rc != -ENODEV && rc != -ENOENT)
+			ieu_err(ieu, "IRU urb %p submission failed (%d)", urb, -rc);
+		usb_unanchor_urb(urb);
+	}
+}
+
+/* allocate + submit + anchor an URB for the interrupt endpoint */
+static int ice1usb_submit_irq_urb(struct ice1usb *ieu, gfp_t mem_flags)
+{
+	unsigned int pipe, size, rc;
+	struct urb *urb;
+	uint8_t *buf;
+
+	if (!ieu->ep.irq)
+		return -ENODEV;
+
+	urb = usb_alloc_urb(0, mem_flags);
+	if (!urb)
+		return -ENOMEM;
+
+	size = le16_to_cpu(ieu->ep.irq->wMaxPacketSize);
+	buf = kmalloc(size, mem_flags);
+	if (!buf) {
+		usb_free_urb(urb);
+		return -ENOMEM;
+	}
+
+	pipe = usb_rcvintpipe(ieu->usb_dev, ieu->ep.irq->bEndpointAddress);
+
+	usb_fill_int_urb(urb, ieu->usb_dev, pipe, buf, size,
+			 ice1usb_irq_complete, ieu, ieu->ep.irq->bInterval);
+
+	urb->transfer_flags |= URB_FREE_BUFFER;
+
+	usb_anchor_urb(urb, &ieu->anchor.irq);
+
+	rc = usb_submit_urb(urb, mem_flags);
+	if (rc < 0) {
+		/* -EPERM: urb is being killed; -ENODEV: device got disconnected */
+		if (rc != -EPERM && rc != -ENODEV && rc != -ENOENT)
+			ieu_err(ieu, "IRQ urb %p submission failed (%d)", urb, -rc);
+		usb_unanchor_urb(urb);
+	}
+
+	/* automatically free the URB (and its transfer buffer) once complete */
+	usb_free_urb(urb);
+
+	return rc;
+}
+
+
+/***********************************************************************
+ * DAHDI integration
+ ***********************************************************************/
+
+static int e1u_d_startup(struct file *file, struct dahdi_span *span);
+
+static int e1u_d_spanconfig(struct file *file, struct dahdi_span *span,
+			    struct dahdi_lineconfig *lc)
+{
+	struct ice1usb *ieu = container_of(span, struct ice1usb, dahdi.span);
+	unsigned int i;
+
+	ieu_dbg(ieu, "entering %s", __FUNCTION__);
+
+	if (lc->sync < 0)
+		lc->sync = 0;
+	if (lc->sync > 1) {
+		ieu_warn(ieu, "Cannot set clock priority on span %d to %d\n",
+			 span->spanno, lc->sync);
+		lc->sync = 0;
+	}
+
+	/* FIXME: use lc->sync to decide LOCAL/REMOTE timing source */
+
+	for (i = 0; i < span->channels; i++) {
+		struct dahdi_chan *const chan = ieu->dahdi.chans[i];
+		chan->sigcap = DAHDI_SIG_CLEAR | DAHDI_SIG_MTP2 | DAHDI_SIG_SF;
+	}
+
+	/* If we're already running, then go ahead and apply the changes */
+	if (span->flags & DAHDI_FLAG_RUNNING)
+		e1u_d_startup(file, span);
+
+	return 0;
+}
+
+static int e1u_d_chanconfig(struct file *file, struct dahdi_chan *chan,
+			    int sigtype)
+{
+	struct ice1usb *ieu = chan->pvt;
+	bool already_running;
+
+	already_running = ieu->dahdi.span.flags & DAHDI_FLAG_RUNNING;
+	ieu_info(ieu, "%sconfigured channel %d (%s) sigtype %d\n",
+		 already_running ? "Re":"", chan->channo, chan->name, sigtype);
+
+	/* FIXME: we can probably remove this completely? */
+	return 0;
+}
+
+static int ice1usb_set_altif(struct ice1usb *ieu, bool on);
+
+static int e1u_d_startup(struct file *file, struct dahdi_span *span)
+{
+	struct ice1usb *ieu = container_of(span, struct ice1usb, dahdi.span);
+	unsigned int i;
+	int rc;
+
+	ieu_dbg(ieu, "entering %s", __FUNCTION__);
+
+	/* TODO: handle CRC4 vs. non-CRC4 case */
+	//if (span->lineconfig & DAHDI_CONFIG_CRC4)
+
+	/* Ensure we are in the right altsetting */
+	rc = ice1usb_set_altif(ieu, true);
+	if (rc < 0)
+		return rc;
+
+	if (!test_and_set_bit(ICE1USB_ISOC_RUNNING, &ieu->flags)) {
+		for (i = 0; i < ICE1USB_NUM_URBS; i++) {
+			rc = ice1usb_submit_isoc_urb(ieu, ieu->ep.iso_in, &ieu->anchor.iso_in,
+						     iso_in_complete, GFP_KERNEL);
+			if (rc) {
+				ieu_err(ieu, "error submitting IN ep URB %u (%d)", i, rc);
+				goto err_isoc;
+			}
+			rc = ice1usb_submit_isoc_urb(ieu, ieu->ep.iso_fb, &ieu->anchor.iso_fb,
+						     iso_fb_complete, GFP_KERNEL);
+			if (rc) {
+				ieu_err(ieu, "error submitting FB ep URB %u (%d)", i, rc);
+				goto err_isoc;
+			}
+			rc = ice1usb_submit_isoc_urb(ieu, ieu->ep.iso_out, &ieu->anchor.iso_out,
+						     iso_out_complete, GFP_KERNEL);
+			if (rc) {
+				ieu_err(ieu, "error submitting OUT ep URB %u (%d)", i, rc);
+				goto err_isoc;
+			}
+		}
+	}
+
+	if (!test_and_set_bit(ICE1USB_IRQ_RUNNING, &ieu->flags)) {
+		for (i = 0; i < ICE1USB_NUM_URBS; i++) {
+			rc = ice1usb_submit_irq_urb(ieu, GFP_KERNEL);
+			if (rc) {
+				ieu_err(ieu, "error submitting IRQ ep %u (%d)", i, rc);
+				goto err_irq;
+			}
+		}
+	}
+
+	return 0;
+
+err_irq:
+	usb_kill_anchored_urbs(&ieu->anchor.irq);
+	clear_bit(ICE1USB_IRQ_RUNNING, &ieu->flags);
+err_isoc:
+	usb_kill_anchored_urbs(&ieu->anchor.iso_in);
+	usb_kill_anchored_urbs(&ieu->anchor.iso_out);
+	usb_kill_anchored_urbs(&ieu->anchor.iso_fb);
+	clear_bit(ICE1USB_ISOC_RUNNING, &ieu->flags);
+	ice1usb_set_altif(ieu, false);
+	return rc;
+}
+
+static int e1u_d_shutdown(struct dahdi_span *span)
+{
+	struct ice1usb *ieu = container_of(span, struct ice1usb, dahdi.span);
+	int rc;
+
+	ieu_dbg(ieu, "entering %s", __FUNCTION__);
+
+	clear_bit(ICE1USB_ISOC_RUNNING, &ieu->flags);
+	clear_bit(ICE1USB_IRQ_RUNNING, &ieu->flags);
+
+	usb_kill_anchored_urbs(&ieu->anchor.iso_in);
+	usb_kill_anchored_urbs(&ieu->anchor.iso_out);
+	usb_kill_anchored_urbs(&ieu->anchor.iso_fb);
+	usb_kill_anchored_urbs(&ieu->anchor.irq);
+
+	/* guard against devices unplugged (see ice1usb_disconnect) */
+	if (ieu->present) {
+		/* switch to 'off' altsetting */
+		rc = ice1usb_set_altif(ieu, false);
+		if (rc < 0)
+			return rc;
+	}
+
+	return 0;
+}
+
+/* set some maintenance mode according to 'cmd' */
+static int e1u_d_maint(struct dahdi_span *span, int cmd)
+{
+	struct ice1usb *ieu = container_of(span, struct ice1usb, dahdi.span);
+
+	ieu_dbg(ieu, "entering %s(%d)", __FUNCTION__, cmd);
+
+	switch (cmd) {
+	case DAHDI_MAINT_NONE:
+		ieu_info(ieu, "Clearing all maint modes\n");
+		/* FIXME */
+		break;
+	case DAHDI_MAINT_NETWORKPAYLOADLOOP:
+		ieu_info(ieu, "Turning on network loopback\n");
+		/* FIXME */
+		break;
+	/* TODO: DAHDI_MAINT_*_DEFECT */
+	default:
+		ieu_info(ieu, "Unknown E1 maint command: %d\n", cmd);
+		return -ENOSYS;
+	}
+
+	return 0;
+}
+
+static const struct dahdi_span_ops ice1usb_span_ops = {
+	.owner = THIS_MODULE,
+	.spanconfig = e1u_d_spanconfig,
+	.chanconfig = e1u_d_chanconfig,
+	.startup = e1u_d_startup,
+	.shutdown = e1u_d_shutdown,
+	.maint = e1u_d_maint,
+};
+
+/***********************************************************************
+ * kernel USB integration / probing 
+ ***********************************************************************/
+
+/* does the given altsetting contain an EP with wMaxPacketSize == 0 ? */
+static bool has_ep_packetsize_zero(const struct usb_host_interface *alt)
+{
+	unsigned int j;
+
+	/* compute the sum of all wMaxPacketSize */
+	for (j = 0; j < alt->desc.bNumEndpoints; j++) {
+		const struct usb_endpoint_descriptor *epd = &alt->endpoint[j].desc;
+		if (usb_endpoint_xfer_isoc(epd)) {
+			if (epd->wMaxPacketSize == 0)
+				return true;
+		}
+	}
+	return false;
+}
+
+/* find the 'on' altsetting (all ISOC EP wMaxPacketSize != 0) */
+static const struct usb_host_interface *find_altsetting_on(struct usb_interface *intf)
+{
+	unsigned int i;
+
+	for (i = 0; i < intf->num_altsetting; i++) {
+		const struct usb_host_interface *alt = &intf->altsetting[i];
+		if (!has_ep_packetsize_zero(alt))
+			return alt;
+	}
+	return NULL;
+}
+
+/* find the 'off' altsetting (all ISOC EP wMaxPacketSize == 0) */
+static const struct usb_host_interface *find_altsetting_off(struct usb_interface *intf)
+{
+	unsigned int i;
+
+	for (i = 0; i < intf->num_altsetting; i++) {
+		const struct usb_host_interface *alt = &intf->altsetting[i];
+		unsigned int iso_ep_size = 0;
+		unsigned int j;
+
+		/* compute the sum of all wMaxPacketSize */
+		for (j = 0; j < alt->desc.bNumEndpoints; j++) {
+			const struct usb_endpoint_descriptor *epd = &alt->endpoint[j].desc;
+			if (usb_endpoint_xfer_isoc(epd))
+				iso_ep_size += le16_to_cpu(epd->wMaxPacketSize);
+		}
+
+		if (iso_ep_size == 0)
+			return alt;
+	}
+	return NULL;
+}
+
+/* find the endpoint numbers within the interface */
+static int find_endpoints(struct ice1usb *ieu, const struct usb_host_interface *alt)
+{
+	unsigned int i;
+	int found = 0;
+
+	for (i = 0; i < alt->desc.bNumEndpoints; i++) {
+		const struct usb_endpoint_descriptor *epd = &alt->endpoint[i].desc;
+		switch (usb_endpoint_type(epd)) {
+		case USB_ENDPOINT_XFER_INT:
+			if (!ieu->ep.irq && usb_endpoint_dir_in(epd)) {
+				ieu->ep.irq = epd;
+				found++;
+			}
+			break;
+		case USB_ENDPOINT_XFER_ISOC:
+			if (usb_endpoint_dir_in(epd)) {
+				if ((epd->bmAttributes & USB_ENDPOINT_USAGE_MASK) ==
+				    USB_ENDPOINT_USAGE_FEEDBACK) {
+					if (!ieu->ep.iso_fb) {
+						ieu->ep.iso_fb = epd;
+						found++;
+					}
+				} else {
+					if (!ieu->ep.iso_in) {
+						ieu->ep.iso_in = epd;
+						found++;
+					}
+				}
+			} else {
+				if (!ieu->ep.iso_out) {
+					ieu->ep.iso_out = epd;
+					found++;
+				}
+			}
+			break;
+		default:
+			break;
+		}
+	}
+	return found;
+}
+
+
+/* select interface altsetting on / off */
+static int ice1usb_set_altif(struct ice1usb *ieu, bool on)
+{
+	const struct usb_interface_descriptor *desc;
+	int rc;
+
+	ieu_dbg(ieu, "entering %s(%d)", __FUNCTION__, on);
+
+	if (on)
+		desc = &ieu->alt_on->desc;
+	else
+		desc = &ieu->alt_off->desc;
+
+	rc = usb_set_interface(ieu->usb_dev, desc->bInterfaceNumber, desc->bAlternateSetting);
+	if (rc) {
+		ieu_err(ieu, "error setting %s-altif %u (%d)",
+			on ? "ON" : "OFF", desc->bInterfaceNumber, rc);
+	}
+
+	return rc;
+}
+
+static int ice1usb_probe(struct usb_interface *intf, const struct usb_device_id *prod)
+{
+	struct usb_device *usb_dev = usb_get_dev(interface_to_usbdev(intf));
+	const struct usb_interface_descriptor *ifdesc = &intf->altsetting->desc;
+	unsigned int max_pack_size;
+	struct dahdi_device *ddev;
+	struct dahdi_span *dspan;
+	struct ice1usb *ieu;
+	int ret = -ENODEV;
+	int rc;
+
+	dev_dbg(&intf->dev, "entering %s", __FUNCTION__);
+
+	if (ifdesc->bInterfaceClass != 0xff || ifdesc->bInterfaceSubClass != 0xE1) {
+		dev_dbg(&intf->dev, "Unsupported Interface Class/SubClass %02x/%02x",
+			ifdesc->bInterfaceClass, ifdesc->bInterfaceSubClass);
+		return -ENODEV;
+	}
+
+	ieu = kzalloc(sizeof(*ieu), GFP_KERNEL);
+	if (!ieu) {
+		dev_err(&intf->dev, "Out of memory\n");
+		return -ENOMEM;
+	}
+
+	ieu->usb_dev = usb_dev;
+	ieu->usb_intf = intf;
+	ieu->fc.r_acc = 0;
+	ieu->fc.r_sw = 8192;
+	ieu->present = true;
+	spin_lock_init(&ieu->lock);
+
+	/* locate ON / OFF altsettings */
+	ieu->alt_off = find_altsetting_off(ieu->usb_intf);
+	if (!ieu->alt_off) {
+		dev_err(&intf->dev, "Cannot find OFF altsetting");
+		goto error;
+	}
+	ieu->alt_on = find_altsetting_on(ieu->usb_intf);
+	if (!ieu->alt_on) {
+		dev_err(&intf->dev, "Cannot find ON altsetting");
+		goto error;
+	}
+
+	/* locate ON / OFF altsettings */
+	if (find_endpoints(ieu, ieu->alt_on) < 4) {
+		dev_err(&intf->dev, "Cannot find all endpoints");
+		goto error;
+	}
+
+	/* compute the maximum number of E1 frames to send in one ISO OUT packet */
+	max_pack_size = le16_to_cpu(ieu->ep.iso_out->wMaxPacketSize);
+	ieu->max_fts = (max_pack_size - 4) / 32;
+	dev_dbg(&intf->dev, "Maximum FTS: %u", ieu->max_fts);
+
+	/* TODO: only one dahdi_device even for multiple USB interfaces? */
+	ddev = ieu->dahdi.dev = dahdi_create_device();
+	if (!ddev)
+		goto error;
+	ddev->manufacturer = usb_dev->manufacturer;
+	ddev->devicetype = usb_dev->product;
+	ddev->hardware_id = usb_dev->serial;
+	//ddev->location = USB_BUS_PATH;
+
+	dspan = &ieu->dahdi.span;
+	snprintf(dspan->name, sizeof(dspan->name), "icE1usb/1/%d",
+		 ieu->alt_on->desc.bInterfaceNumber); //TDOO: device != 1
+	snprintf(dspan->desc, sizeof(dspan->desc), "Osmocom icE1USB Card 1 Span %d",
+		 ieu->alt_on->desc.bInterfaceNumber); //TODO: device != 1
+	dspan->channels = 31;
+	dspan->spantype = SPANTYPE_DIGITAL_E1;
+	dspan->deflaw = DAHDI_LAW_ALAW;
+	dspan->linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
+	dspan->chans = ieu->dahdi.chans;
+	dspan->flags = 0;
+	dspan->offset = 0;
+	dspan->ops = &ice1usb_span_ops;
+
+	rc = e1u_alloc_channels(ieu);
+	if (rc) {
+		ret = -ENOMEM;
+		goto err_free_ddev;
+	}
+
+	list_add_tail(&dspan->device_node, &ddev->spans);
+
+	rc = dahdi_register_device(ieu->dahdi.dev, &intf->dev);
+	if (rc) {
+		dev_err(&intf->dev, "Failed to reigster with DAHDI\n");
+		goto err_free_chans;
+	}
+
+	init_usb_anchor(&ieu->anchor.iso_in);
+	init_usb_anchor(&ieu->anchor.iso_out);
+	init_usb_anchor(&ieu->anchor.iso_fb);
+	init_usb_anchor(&ieu->anchor.irq);
+
+	usb_set_intfdata(intf, ieu);
+
+	return 0;
+
+err_free_chans:
+	e1u_free_channels(ieu);
+err_free_ddev:
+	dahdi_free_device(ieu->dahdi.dev);
+error:
+	kfree(ieu);
+	return ret;
+}
+
+static struct usb_driver ice1usb_driver;
+
+static void ice1usb_disconnect(struct usb_interface *intf)
+{
+	struct ice1usb *ieu = usb_get_intfdata(intf);
+
+	dev_dbg(&intf->dev, "entering %s", __FUNCTION__);
+
+	if (!ieu)
+		return;
+
+	/* avoid any shutdown code from submitting further I/O */
+	ieu->present = false;
+
+	usb_set_intfdata(intf, NULL);
+
+	/* will in turn call e1u_d_shutdown() which stops all transfers */
+	dahdi_unregister_device(ieu->dahdi.dev);
+
+	ice1usb_free(ieu);
+}
+
+#if 0
+static int ice1usb_suspend(struct usb_interface *intf, pm_message_t message)
+{
+	struct ice1usb *ieu = usb_get_intfdata(intf);
+	/* FIXME */
+}
+
+static int ice1usb_resume(struct usb_interface *intf)
+{
+	struct ice1usb *ieu = usb_get_intfdata(intf);
+	/* FIXME */
+}
+#endif
+
+static const struct usb_device_id ice1usb_products[] = {
+	{
+		USB_DEVICE(0x1d50, 0x6145),
+	},
+	{}
+};
+
+static struct usb_driver ice1usb_driver = {
+	.name = "icE1usb",
+	.id_table = ice1usb_products,
+	.probe = ice1usb_probe,
+	.disconnect = ice1usb_disconnect,
+	//.suspend = ice1usb_suspend,
+	//.resume = ice1usb_resume,
+};
+
+module_usb_driver(ice1usb_driver);
+
+MODULE_AUTHOR("Harald Welte <laforge@osmocom.org>");
+MODULE_DESCRIPTION("Osmocom icE1usb USB E1 interface");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(VERSION);
diff --git a/drivers/dahdi/icE1usb/ice1usb_proto.h b/drivers/dahdi/icE1usb/ice1usb_proto.h
new file mode 100644
index 0000000..5f5f31c
--- /dev/null
+++ b/drivers/dahdi/icE1usb/ice1usb_proto.h
@@ -0,0 +1,99 @@
+#pragma once
+
+/* Header file describing the USB protocol between the icE1usb firmware and the host
+ * software (currently really only osmo-e1d) */
+
+/***********************************************************************
+ * Control Endpoint / Device Requests
+ ***********************************************************************/
+
+/*! returns a bit-mask of optional device capabilities (see enum e1usb_dev_capability) */
+#define ICE1USB_DEV_GET_CAPABILITIES	0x01
+#define ICE1USB_DEV_GET_FW_BUILD	0x02
+
+enum e1usb_dev_capability {
+	/*! Does this board have a GPS-DO */
+	ICE1USB_DEV_CAP_GPSDO,
+};
+
+
+/* Interface Requests */
+
+/*! returns a bit-mask of optional device capabilities (see enum e1usb_intf_capability) */
+#define ICE1USB_INTF_GET_CAPABILITIES	0x01
+#define ICE1USB_INTF_SET_TX_CFG		0x02	/*!< struct ice1usb_tx_config */
+#define ICE1USB_INTF_GET_TX_CFG		0x03	/*!< struct ice1usb_tx_config */
+#define ICE1USB_INTF_SET_RX_CFG		0x04	/*!< struct ice1usb_rx_config */
+#define ICE1USB_INTF_GET_RX_CFG		0x05	/*!< struct ice1usb_rx_config */
+
+//enum e1usb_intf_capability { };
+
+enum ice1usb_tx_mode {
+	ICE1USB_TX_MODE_TRANSP		= 0,
+	ICE1USB_TX_MODE_TS0		= 1,
+	ICE1USB_TX_MODE_TS0_CRC4	= 2,
+	ICE1USB_TX_MODE_TS0_CRC4_E	= 3,
+};
+
+enum ice1usb_tx_timing {
+	ICE1USB_TX_TIME_SRC_LOCAL	= 0,
+	ICE1USB_TX_TIME_SRC_REMOTE	= 1,
+};
+
+enum ice1usb_tx_ext_loopback {
+	ICE1USB_TX_EXT_LOOPBACK_OFF	= 0,
+	ICE1USB_TX_EXT_LOOPBACK_SAME	= 1,
+	ICE1USB_TX_EXT_LOOPBACK_CROSS	= 2,
+};
+
+/* ICE1USB_INTF_{GET,SET}_TX_CFG */
+struct ice1usb_tx_config {
+	uint8_t mode;		/*!< enum ice1usb_tx_mode */
+	uint8_t timing;		/*!< enum ice1usb_tx_timing */
+	uint8_t ext_loopback;	/*!< enum ice1usb_tx_ext_loopback */
+	uint8_t alarm;		/*!< 1 = transmit alarm; 0 = don't */
+} __attribute__((packed));
+
+
+enum ice1usb_rx_mode {
+	/*! transparent, unaligned bitstream */
+	ICE1USB_RX_MODE_TRANSP		= 0,
+	/*! alignment to E1 frame */
+	ICE1USB_RX_MODE_FRAME		= 2,
+	/*! alignment to E1 multiframe */
+	ICE1USB_RX_MODE_MULTIFRAME	= 3,
+};
+
+/* ICE1USB_INTF_{GET,SET}_RX_CFG */
+struct ice1usb_rx_config {
+	uint8_t mode;		/*!< enum ice1usb_rx_mode */
+} __attribute__((packed));
+
+
+/***********************************************************************
+ * Interrupt Endpoint
+ ***********************************************************************/
+
+enum ice1usb_irq_type {
+	ICE1USB_IRQQ_T_ERRCNT		= 1,
+};
+
+/* Ensue ro keep those in sync with e1.h */
+#define ICE1USB_ERR_F_ALIGN_ERR	0x01
+#define ICE1USB_ERR_F_TICK_ERR	0x02
+
+struct ice1usb_irq_err {
+	/* 16-bit little-endian counters */
+	uint16_t crc;
+	uint16_t align;
+	uint16_t ovfl;
+	uint16_t unfl;
+	uint8_t flags;
+} __attribute__((packed));
+
+struct ice1usb_irq {
+	uint8_t type; 		/*!< enum ice1usb_irq_type */
+	union {
+		struct ice1usb_irq_err errors;
+	} u;
+} __attribute__((packed));
-- 
2.34.0

Places

File 0001-Add-Osmocom-icE1usb-driver.patch of Package dahdi-linux (Revision 2709b2bb561c793e2a1bfda703339f23)

Places