1a53d1202SEli Billauer // SPDX-License-Identifier: GPL-2.0-only
2a53d1202SEli Billauer /*
3a53d1202SEli Billauer * Copyright 2020 Xillybus Ltd, http://xillybus.com
4a53d1202SEli Billauer *
5a53d1202SEli Billauer * Driver for the XillyUSB FPGA/host framework.
6a53d1202SEli Billauer *
7a53d1202SEli Billauer * This driver interfaces with a special IP core in an FPGA, setting up
8a53d1202SEli Billauer * a pipe between a hardware FIFO in the programmable logic and a device
9a53d1202SEli Billauer * file in the host. The number of such pipes and their attributes are
10a53d1202SEli Billauer * set up on the logic. This driver detects these automatically and
11a53d1202SEli Billauer * creates the device files accordingly.
12a53d1202SEli Billauer */
13a53d1202SEli Billauer
14a53d1202SEli Billauer #include <linux/types.h>
15a53d1202SEli Billauer #include <linux/slab.h>
16a53d1202SEli Billauer #include <linux/list.h>
17a53d1202SEli Billauer #include <linux/device.h>
18a53d1202SEli Billauer #include <linux/module.h>
19a53d1202SEli Billauer #include <asm/byteorder.h>
20a53d1202SEli Billauer #include <linux/io.h>
21a53d1202SEli Billauer #include <linux/interrupt.h>
22a53d1202SEli Billauer #include <linux/sched.h>
23a53d1202SEli Billauer #include <linux/fs.h>
24a53d1202SEli Billauer #include <linux/spinlock.h>
25a53d1202SEli Billauer #include <linux/mutex.h>
26a53d1202SEli Billauer #include <linux/workqueue.h>
27a53d1202SEli Billauer #include <linux/crc32.h>
28a53d1202SEli Billauer #include <linux/poll.h>
29a53d1202SEli Billauer #include <linux/delay.h>
30a53d1202SEli Billauer #include <linux/usb.h>
31a53d1202SEli Billauer
32a53d1202SEli Billauer #include "xillybus_class.h"
33a53d1202SEli Billauer
34a53d1202SEli Billauer MODULE_DESCRIPTION("Driver for XillyUSB FPGA IP Core");
35a53d1202SEli Billauer MODULE_AUTHOR("Eli Billauer, Xillybus Ltd.");
36a53d1202SEli Billauer MODULE_ALIAS("xillyusb");
37a53d1202SEli Billauer MODULE_LICENSE("GPL v2");
38a53d1202SEli Billauer
39a53d1202SEli Billauer #define XILLY_RX_TIMEOUT (10 * HZ / 1000)
40a53d1202SEli Billauer #define XILLY_RESPONSE_TIMEOUT (500 * HZ / 1000)
41a53d1202SEli Billauer
42a53d1202SEli Billauer #define BUF_SIZE_ORDER 4
43a53d1202SEli Billauer #define BUFNUM 8
44a53d1202SEli Billauer #define LOG2_IDT_FIFO_SIZE 16
45a53d1202SEli Billauer #define LOG2_INITIAL_FIFO_BUF_SIZE 16
46a53d1202SEli Billauer
47a53d1202SEli Billauer #define MSG_EP_NUM 1
48a53d1202SEli Billauer #define IN_EP_NUM 1
49a53d1202SEli Billauer
50a53d1202SEli Billauer static const char xillyname[] = "xillyusb";
51a53d1202SEli Billauer
52a53d1202SEli Billauer static unsigned int fifo_buf_order;
53a7ad105bSEli Billauer static struct workqueue_struct *wakeup_wq;
54a53d1202SEli Billauer
55a53d1202SEli Billauer #define USB_VENDOR_ID_XILINX 0x03fd
56a53d1202SEli Billauer #define USB_VENDOR_ID_ALTERA 0x09fb
57a53d1202SEli Billauer
58a53d1202SEli Billauer #define USB_PRODUCT_ID_XILLYUSB 0xebbe
59a53d1202SEli Billauer
60a53d1202SEli Billauer static const struct usb_device_id xillyusb_table[] = {
61a53d1202SEli Billauer { USB_DEVICE(USB_VENDOR_ID_XILINX, USB_PRODUCT_ID_XILLYUSB) },
62a53d1202SEli Billauer { USB_DEVICE(USB_VENDOR_ID_ALTERA, USB_PRODUCT_ID_XILLYUSB) },
63a53d1202SEli Billauer { }
64a53d1202SEli Billauer };
65a53d1202SEli Billauer
66a53d1202SEli Billauer MODULE_DEVICE_TABLE(usb, xillyusb_table);
67a53d1202SEli Billauer
68a53d1202SEli Billauer struct xillyusb_dev;
69a53d1202SEli Billauer
70a53d1202SEli Billauer struct xillyfifo {
71a53d1202SEli Billauer unsigned int bufsize; /* In bytes, always a power of 2 */
72a53d1202SEli Billauer unsigned int bufnum;
73a53d1202SEli Billauer unsigned int size; /* Lazy: Equals bufsize * bufnum */
74a53d1202SEli Billauer unsigned int buf_order;
75a53d1202SEli Billauer
76a53d1202SEli Billauer int fill; /* Number of bytes in the FIFO */
77a53d1202SEli Billauer spinlock_t lock;
78a53d1202SEli Billauer wait_queue_head_t waitq;
79a53d1202SEli Billauer
80a53d1202SEli Billauer unsigned int readpos;
81a53d1202SEli Billauer unsigned int readbuf;
82a53d1202SEli Billauer unsigned int writepos;
83a53d1202SEli Billauer unsigned int writebuf;
84a53d1202SEli Billauer char **mem;
85a53d1202SEli Billauer };
86a53d1202SEli Billauer
87a53d1202SEli Billauer struct xillyusb_channel;
88a53d1202SEli Billauer
89a53d1202SEli Billauer struct xillyusb_endpoint {
90a53d1202SEli Billauer struct xillyusb_dev *xdev;
91a53d1202SEli Billauer
92a53d1202SEli Billauer struct mutex ep_mutex; /* serialize operations on endpoint */
93a53d1202SEli Billauer
94a53d1202SEli Billauer struct list_head buffers;
95a53d1202SEli Billauer struct list_head filled_buffers;
96a53d1202SEli Billauer spinlock_t buffers_lock; /* protect these two lists */
97a53d1202SEli Billauer
98a53d1202SEli Billauer unsigned int order;
99a53d1202SEli Billauer unsigned int buffer_size;
100a53d1202SEli Billauer
101a53d1202SEli Billauer unsigned int fill_mask;
102a53d1202SEli Billauer
103a53d1202SEli Billauer int outstanding_urbs;
104a53d1202SEli Billauer
105a53d1202SEli Billauer struct usb_anchor anchor;
106a53d1202SEli Billauer
107a53d1202SEli Billauer struct xillyfifo fifo;
108a53d1202SEli Billauer
109a53d1202SEli Billauer struct work_struct workitem;
110a53d1202SEli Billauer
111a53d1202SEli Billauer bool shutting_down;
112a53d1202SEli Billauer bool drained;
113a53d1202SEli Billauer bool wake_on_drain;
114a53d1202SEli Billauer
115a53d1202SEli Billauer u8 ep_num;
116a53d1202SEli Billauer };
117a53d1202SEli Billauer
118a53d1202SEli Billauer struct xillyusb_channel {
119a53d1202SEli Billauer struct xillyusb_dev *xdev;
120a53d1202SEli Billauer
121a53d1202SEli Billauer struct xillyfifo *in_fifo;
122a53d1202SEli Billauer struct xillyusb_endpoint *out_ep;
123a53d1202SEli Billauer struct mutex lock; /* protect @out_ep, @in_fifo, bit fields below */
124a53d1202SEli Billauer
125a53d1202SEli Billauer struct mutex in_mutex; /* serialize fops on FPGA to host stream */
126a53d1202SEli Billauer struct mutex out_mutex; /* serialize fops on host to FPGA stream */
127a53d1202SEli Billauer wait_queue_head_t flushq;
128a53d1202SEli Billauer
129a53d1202SEli Billauer int chan_idx;
130a53d1202SEli Billauer
131a53d1202SEli Billauer u32 in_consumed_bytes;
132a53d1202SEli Billauer u32 in_current_checkpoint;
133a53d1202SEli Billauer u32 out_bytes;
134a53d1202SEli Billauer
135a53d1202SEli Billauer unsigned int in_log2_element_size;
136a53d1202SEli Billauer unsigned int out_log2_element_size;
137a53d1202SEli Billauer unsigned int in_log2_fifo_size;
138a53d1202SEli Billauer unsigned int out_log2_fifo_size;
139a53d1202SEli Billauer
140a53d1202SEli Billauer unsigned int read_data_ok; /* EOF not arrived (yet) */
141a53d1202SEli Billauer unsigned int poll_used;
142a53d1202SEli Billauer unsigned int flushing;
143a53d1202SEli Billauer unsigned int flushed;
144a53d1202SEli Billauer unsigned int canceled;
145a53d1202SEli Billauer
146a53d1202SEli Billauer /* Bit fields protected by @lock except for initialization */
147a53d1202SEli Billauer unsigned readable:1;
148a53d1202SEli Billauer unsigned writable:1;
149a53d1202SEli Billauer unsigned open_for_read:1;
150a53d1202SEli Billauer unsigned open_for_write:1;
151a53d1202SEli Billauer unsigned in_synchronous:1;
152a53d1202SEli Billauer unsigned out_synchronous:1;
153a53d1202SEli Billauer unsigned in_seekable:1;
154a53d1202SEli Billauer unsigned out_seekable:1;
155a53d1202SEli Billauer };
156a53d1202SEli Billauer
157a53d1202SEli Billauer struct xillybuffer {
158a53d1202SEli Billauer struct list_head entry;
159a53d1202SEli Billauer struct xillyusb_endpoint *ep;
160a53d1202SEli Billauer void *buf;
161a53d1202SEli Billauer unsigned int len;
162a53d1202SEli Billauer };
163a53d1202SEli Billauer
164a53d1202SEli Billauer struct xillyusb_dev {
165a53d1202SEli Billauer struct xillyusb_channel *channels;
166a53d1202SEli Billauer
167a53d1202SEli Billauer struct usb_device *udev;
168a53d1202SEli Billauer struct device *dev; /* For dev_err() and such */
169a53d1202SEli Billauer struct kref kref;
170a53d1202SEli Billauer struct workqueue_struct *workq;
171a53d1202SEli Billauer
172a53d1202SEli Billauer int error;
173a53d1202SEli Billauer spinlock_t error_lock; /* protect @error */
174a53d1202SEli Billauer struct work_struct wakeup_workitem;
175a53d1202SEli Billauer
176a53d1202SEli Billauer int num_channels;
177a53d1202SEli Billauer
178a53d1202SEli Billauer struct xillyusb_endpoint *msg_ep;
179a53d1202SEli Billauer struct xillyusb_endpoint *in_ep;
180a53d1202SEli Billauer
181a53d1202SEli Billauer struct mutex msg_mutex; /* serialize opcode transmission */
182a53d1202SEli Billauer int in_bytes_left;
183a53d1202SEli Billauer int leftover_chan_num;
184a53d1202SEli Billauer unsigned int in_counter;
185a53d1202SEli Billauer struct mutex process_in_mutex; /* synchronize wakeup_all() */
186a53d1202SEli Billauer };
187a53d1202SEli Billauer
188282a4b71SEli Billauer /*
189282a4b71SEli Billauer * kref_mutex is used in xillyusb_open() to prevent the xillyusb_dev
190282a4b71SEli Billauer * struct from being freed during the gap between being found by
191282a4b71SEli Billauer * xillybus_find_inode() and having its reference count incremented.
192282a4b71SEli Billauer */
193282a4b71SEli Billauer
194282a4b71SEli Billauer static DEFINE_MUTEX(kref_mutex);
195282a4b71SEli Billauer
196a53d1202SEli Billauer /* FPGA to host opcodes */
197a53d1202SEli Billauer enum {
198a53d1202SEli Billauer OPCODE_DATA = 0,
199a53d1202SEli Billauer OPCODE_QUIESCE_ACK = 1,
200a53d1202SEli Billauer OPCODE_EOF = 2,
201a53d1202SEli Billauer OPCODE_REACHED_CHECKPOINT = 3,
202a53d1202SEli Billauer OPCODE_CANCELED_CHECKPOINT = 4,
203a53d1202SEli Billauer };
204a53d1202SEli Billauer
205a53d1202SEli Billauer /* Host to FPGA opcodes */
206a53d1202SEli Billauer enum {
207a53d1202SEli Billauer OPCODE_QUIESCE = 0,
208a53d1202SEli Billauer OPCODE_REQ_IDT = 1,
209a53d1202SEli Billauer OPCODE_SET_CHECKPOINT = 2,
210a53d1202SEli Billauer OPCODE_CLOSE = 3,
211a53d1202SEli Billauer OPCODE_SET_PUSH = 4,
212a53d1202SEli Billauer OPCODE_UPDATE_PUSH = 5,
213a53d1202SEli Billauer OPCODE_CANCEL_CHECKPOINT = 6,
214a53d1202SEli Billauer OPCODE_SET_ADDR = 7,
215a53d1202SEli Billauer };
216a53d1202SEli Billauer
217a53d1202SEli Billauer /*
218a53d1202SEli Billauer * fifo_write() and fifo_read() are NOT reentrant (i.e. concurrent multiple
219a53d1202SEli Billauer * calls to each on the same FIFO is not allowed) however it's OK to have
220a53d1202SEli Billauer * threads calling each of the two functions once on the same FIFO, and
221a53d1202SEli Billauer * at the same time.
222a53d1202SEli Billauer */
223a53d1202SEli Billauer
fifo_write(struct xillyfifo * fifo,const void * data,unsigned int len,int (* copier)(void *,const void *,int))224a53d1202SEli Billauer static int fifo_write(struct xillyfifo *fifo,
225a53d1202SEli Billauer const void *data, unsigned int len,
226a53d1202SEli Billauer int (*copier)(void *, const void *, int))
227a53d1202SEli Billauer {
228a53d1202SEli Billauer unsigned int done = 0;
229a53d1202SEli Billauer unsigned int todo = len;
230a53d1202SEli Billauer unsigned int nmax;
231a53d1202SEli Billauer unsigned int writepos = fifo->writepos;
232a53d1202SEli Billauer unsigned int writebuf = fifo->writebuf;
233a53d1202SEli Billauer unsigned long flags;
234a53d1202SEli Billauer int rc;
235a53d1202SEli Billauer
236a53d1202SEli Billauer nmax = fifo->size - READ_ONCE(fifo->fill);
237a53d1202SEli Billauer
238a53d1202SEli Billauer while (1) {
239a53d1202SEli Billauer unsigned int nrail = fifo->bufsize - writepos;
240a53d1202SEli Billauer unsigned int n = min(todo, nmax);
241a53d1202SEli Billauer
242a53d1202SEli Billauer if (n == 0) {
243a53d1202SEli Billauer spin_lock_irqsave(&fifo->lock, flags);
244a53d1202SEli Billauer fifo->fill += done;
245a53d1202SEli Billauer spin_unlock_irqrestore(&fifo->lock, flags);
246a53d1202SEli Billauer
247a53d1202SEli Billauer fifo->writepos = writepos;
248a53d1202SEli Billauer fifo->writebuf = writebuf;
249a53d1202SEli Billauer
250a53d1202SEli Billauer return done;
251a53d1202SEli Billauer }
252a53d1202SEli Billauer
253a53d1202SEli Billauer if (n > nrail)
254a53d1202SEli Billauer n = nrail;
255a53d1202SEli Billauer
256a53d1202SEli Billauer rc = (*copier)(fifo->mem[writebuf] + writepos, data + done, n);
257a53d1202SEli Billauer
258a53d1202SEli Billauer if (rc)
259a53d1202SEli Billauer return rc;
260a53d1202SEli Billauer
261a53d1202SEli Billauer done += n;
262a53d1202SEli Billauer todo -= n;
263a53d1202SEli Billauer
264a53d1202SEli Billauer writepos += n;
265a53d1202SEli Billauer nmax -= n;
266a53d1202SEli Billauer
267a53d1202SEli Billauer if (writepos == fifo->bufsize) {
268a53d1202SEli Billauer writepos = 0;
269a53d1202SEli Billauer writebuf++;
270a53d1202SEli Billauer
271a53d1202SEli Billauer if (writebuf == fifo->bufnum)
272a53d1202SEli Billauer writebuf = 0;
273a53d1202SEli Billauer }
274a53d1202SEli Billauer }
275a53d1202SEli Billauer }
276a53d1202SEli Billauer
fifo_read(struct xillyfifo * fifo,void * data,unsigned int len,int (* copier)(void *,const void *,int))277a53d1202SEli Billauer static int fifo_read(struct xillyfifo *fifo,
278a53d1202SEli Billauer void *data, unsigned int len,
279a53d1202SEli Billauer int (*copier)(void *, const void *, int))
280a53d1202SEli Billauer {
281a53d1202SEli Billauer unsigned int done = 0;
282a53d1202SEli Billauer unsigned int todo = len;
283a53d1202SEli Billauer unsigned int fill;
284a53d1202SEli Billauer unsigned int readpos = fifo->readpos;
285a53d1202SEli Billauer unsigned int readbuf = fifo->readbuf;
286a53d1202SEli Billauer unsigned long flags;
287a53d1202SEli Billauer int rc;
288a53d1202SEli Billauer
289a53d1202SEli Billauer /*
290a53d1202SEli Billauer * The spinlock here is necessary, because otherwise fifo->fill
291a53d1202SEli Billauer * could have been increased by fifo_write() after writing data
292a53d1202SEli Billauer * to the buffer, but this data would potentially not have been
293a53d1202SEli Billauer * visible on this thread at the time the updated fifo->fill was.
294a53d1202SEli Billauer * That could lead to reading invalid data.
295a53d1202SEli Billauer */
296a53d1202SEli Billauer
297a53d1202SEli Billauer spin_lock_irqsave(&fifo->lock, flags);
298a53d1202SEli Billauer fill = fifo->fill;
299a53d1202SEli Billauer spin_unlock_irqrestore(&fifo->lock, flags);
300a53d1202SEli Billauer
301a53d1202SEli Billauer while (1) {
302a53d1202SEli Billauer unsigned int nrail = fifo->bufsize - readpos;
303a53d1202SEli Billauer unsigned int n = min(todo, fill);
304a53d1202SEli Billauer
305a53d1202SEli Billauer if (n == 0) {
306a53d1202SEli Billauer spin_lock_irqsave(&fifo->lock, flags);
307a53d1202SEli Billauer fifo->fill -= done;
308a53d1202SEli Billauer spin_unlock_irqrestore(&fifo->lock, flags);
309a53d1202SEli Billauer
310a53d1202SEli Billauer fifo->readpos = readpos;
311a53d1202SEli Billauer fifo->readbuf = readbuf;
312a53d1202SEli Billauer
313a53d1202SEli Billauer return done;
314a53d1202SEli Billauer }
315a53d1202SEli Billauer
316a53d1202SEli Billauer if (n > nrail)
317a53d1202SEli Billauer n = nrail;
318a53d1202SEli Billauer
319a53d1202SEli Billauer rc = (*copier)(data + done, fifo->mem[readbuf] + readpos, n);
320a53d1202SEli Billauer
321a53d1202SEli Billauer if (rc)
322a53d1202SEli Billauer return rc;
323a53d1202SEli Billauer
324a53d1202SEli Billauer done += n;
325a53d1202SEli Billauer todo -= n;
326a53d1202SEli Billauer
327a53d1202SEli Billauer readpos += n;
328a53d1202SEli Billauer fill -= n;
329a53d1202SEli Billauer
330a53d1202SEli Billauer if (readpos == fifo->bufsize) {
331a53d1202SEli Billauer readpos = 0;
332a53d1202SEli Billauer readbuf++;
333a53d1202SEli Billauer
334a53d1202SEli Billauer if (readbuf == fifo->bufnum)
335a53d1202SEli Billauer readbuf = 0;
336a53d1202SEli Billauer }
337a53d1202SEli Billauer }
338a53d1202SEli Billauer }
339a53d1202SEli Billauer
340a53d1202SEli Billauer /*
341a53d1202SEli Billauer * These three wrapper functions are used as the @copier argument to
342a53d1202SEli Billauer * fifo_write() and fifo_read(), so that they can work directly with
343a53d1202SEli Billauer * user memory as well.
344a53d1202SEli Billauer */
345a53d1202SEli Billauer
xilly_copy_from_user(void * dst,const void * src,int n)346a53d1202SEli Billauer static int xilly_copy_from_user(void *dst, const void *src, int n)
347a53d1202SEli Billauer {
348a53d1202SEli Billauer if (copy_from_user(dst, (const void __user *)src, n))
349a53d1202SEli Billauer return -EFAULT;
350a53d1202SEli Billauer
351a53d1202SEli Billauer return 0;
352a53d1202SEli Billauer }
353a53d1202SEli Billauer
xilly_copy_to_user(void * dst,const void * src,int n)354a53d1202SEli Billauer static int xilly_copy_to_user(void *dst, const void *src, int n)
355a53d1202SEli Billauer {
356a53d1202SEli Billauer if (copy_to_user((void __user *)dst, src, n))
357a53d1202SEli Billauer return -EFAULT;
358a53d1202SEli Billauer
359a53d1202SEli Billauer return 0;
360a53d1202SEli Billauer }
361a53d1202SEli Billauer
xilly_memcpy(void * dst,const void * src,int n)362a53d1202SEli Billauer static int xilly_memcpy(void *dst, const void *src, int n)
363a53d1202SEli Billauer {
364a53d1202SEli Billauer memcpy(dst, src, n);
365a53d1202SEli Billauer
366a53d1202SEli Billauer return 0;
367a53d1202SEli Billauer }
368a53d1202SEli Billauer
fifo_init(struct xillyfifo * fifo,unsigned int log2_size)369a53d1202SEli Billauer static int fifo_init(struct xillyfifo *fifo,
370a53d1202SEli Billauer unsigned int log2_size)
371a53d1202SEli Billauer {
372a53d1202SEli Billauer unsigned int log2_bufnum;
373a53d1202SEli Billauer unsigned int buf_order;
374a53d1202SEli Billauer int i;
375a53d1202SEli Billauer
376a53d1202SEli Billauer unsigned int log2_fifo_buf_size;
377a53d1202SEli Billauer
378a53d1202SEli Billauer retry:
379a53d1202SEli Billauer log2_fifo_buf_size = fifo_buf_order + PAGE_SHIFT;
380a53d1202SEli Billauer
381a53d1202SEli Billauer if (log2_size > log2_fifo_buf_size) {
382a53d1202SEli Billauer log2_bufnum = log2_size - log2_fifo_buf_size;
383a53d1202SEli Billauer buf_order = fifo_buf_order;
384a53d1202SEli Billauer fifo->bufsize = 1 << log2_fifo_buf_size;
385a53d1202SEli Billauer } else {
386a53d1202SEli Billauer log2_bufnum = 0;
387a53d1202SEli Billauer buf_order = (log2_size > PAGE_SHIFT) ?
388a53d1202SEli Billauer log2_size - PAGE_SHIFT : 0;
389a53d1202SEli Billauer fifo->bufsize = 1 << log2_size;
390a53d1202SEli Billauer }
391a53d1202SEli Billauer
392a53d1202SEli Billauer fifo->bufnum = 1 << log2_bufnum;
393a53d1202SEli Billauer fifo->size = fifo->bufnum * fifo->bufsize;
394a53d1202SEli Billauer fifo->buf_order = buf_order;
395a53d1202SEli Billauer
396a53d1202SEli Billauer fifo->mem = kmalloc_array(fifo->bufnum, sizeof(void *), GFP_KERNEL);
397a53d1202SEli Billauer
398a53d1202SEli Billauer if (!fifo->mem)
399a53d1202SEli Billauer return -ENOMEM;
400a53d1202SEli Billauer
401a53d1202SEli Billauer for (i = 0; i < fifo->bufnum; i++) {
402a53d1202SEli Billauer fifo->mem[i] = (void *)
403a53d1202SEli Billauer __get_free_pages(GFP_KERNEL, buf_order);
404a53d1202SEli Billauer
405a53d1202SEli Billauer if (!fifo->mem[i])
406a53d1202SEli Billauer goto memfail;
407a53d1202SEli Billauer }
408a53d1202SEli Billauer
409a53d1202SEli Billauer fifo->fill = 0;
410a53d1202SEli Billauer fifo->readpos = 0;
411a53d1202SEli Billauer fifo->readbuf = 0;
412a53d1202SEli Billauer fifo->writepos = 0;
413a53d1202SEli Billauer fifo->writebuf = 0;
414a53d1202SEli Billauer spin_lock_init(&fifo->lock);
415a53d1202SEli Billauer init_waitqueue_head(&fifo->waitq);
416a53d1202SEli Billauer return 0;
417a53d1202SEli Billauer
418a53d1202SEli Billauer memfail:
419a53d1202SEli Billauer for (i--; i >= 0; i--)
420a53d1202SEli Billauer free_pages((unsigned long)fifo->mem[i], buf_order);
421a53d1202SEli Billauer
422a53d1202SEli Billauer kfree(fifo->mem);
423a53d1202SEli Billauer fifo->mem = NULL;
424a53d1202SEli Billauer
425a53d1202SEli Billauer if (fifo_buf_order) {
426a53d1202SEli Billauer fifo_buf_order--;
427a53d1202SEli Billauer goto retry;
428a53d1202SEli Billauer } else {
429a53d1202SEli Billauer return -ENOMEM;
430a53d1202SEli Billauer }
431a53d1202SEli Billauer }
432a53d1202SEli Billauer
fifo_mem_release(struct xillyfifo * fifo)433a53d1202SEli Billauer static void fifo_mem_release(struct xillyfifo *fifo)
434a53d1202SEli Billauer {
435a53d1202SEli Billauer int i;
436a53d1202SEli Billauer
437a53d1202SEli Billauer if (!fifo->mem)
438a53d1202SEli Billauer return;
439a53d1202SEli Billauer
440a53d1202SEli Billauer for (i = 0; i < fifo->bufnum; i++)
441a53d1202SEli Billauer free_pages((unsigned long)fifo->mem[i], fifo->buf_order);
442a53d1202SEli Billauer
443a53d1202SEli Billauer kfree(fifo->mem);
444a53d1202SEli Billauer }
445a53d1202SEli Billauer
446a53d1202SEli Billauer /*
447a53d1202SEli Billauer * When endpoint_quiesce() returns, the endpoint has no URBs submitted,
448a53d1202SEli Billauer * won't accept any new URB submissions, and its related work item doesn't
449a53d1202SEli Billauer * and won't run anymore.
450a53d1202SEli Billauer */
451a53d1202SEli Billauer
endpoint_quiesce(struct xillyusb_endpoint * ep)452a53d1202SEli Billauer static void endpoint_quiesce(struct xillyusb_endpoint *ep)
453a53d1202SEli Billauer {
454a53d1202SEli Billauer mutex_lock(&ep->ep_mutex);
455a53d1202SEli Billauer ep->shutting_down = true;
456a53d1202SEli Billauer mutex_unlock(&ep->ep_mutex);
457a53d1202SEli Billauer
458a53d1202SEli Billauer usb_kill_anchored_urbs(&ep->anchor);
459a53d1202SEli Billauer cancel_work_sync(&ep->workitem);
460a53d1202SEli Billauer }
461a53d1202SEli Billauer
462a53d1202SEli Billauer /*
463a53d1202SEli Billauer * Note that endpoint_dealloc() also frees fifo memory (if allocated), even
464a53d1202SEli Billauer * though endpoint_alloc doesn't allocate that memory.
465a53d1202SEli Billauer */
466a53d1202SEli Billauer
endpoint_dealloc(struct xillyusb_endpoint * ep)467a53d1202SEli Billauer static void endpoint_dealloc(struct xillyusb_endpoint *ep)
468a53d1202SEli Billauer {
469a53d1202SEli Billauer struct list_head *this, *next;
470a53d1202SEli Billauer
471a53d1202SEli Billauer fifo_mem_release(&ep->fifo);
472a53d1202SEli Billauer
473a53d1202SEli Billauer /* Join @filled_buffers with @buffers to free these entries too */
474a53d1202SEli Billauer list_splice(&ep->filled_buffers, &ep->buffers);
475a53d1202SEli Billauer
476a53d1202SEli Billauer list_for_each_safe(this, next, &ep->buffers) {
477a53d1202SEli Billauer struct xillybuffer *xb =
478a53d1202SEli Billauer list_entry(this, struct xillybuffer, entry);
479a53d1202SEli Billauer
480a53d1202SEli Billauer free_pages((unsigned long)xb->buf, ep->order);
481a53d1202SEli Billauer kfree(xb);
482a53d1202SEli Billauer }
483a53d1202SEli Billauer
484a53d1202SEli Billauer kfree(ep);
485a53d1202SEli Billauer }
486a53d1202SEli Billauer
487a53d1202SEli Billauer static struct xillyusb_endpoint
endpoint_alloc(struct xillyusb_dev * xdev,u8 ep_num,void (* work)(struct work_struct *),unsigned int order,int bufnum)488a53d1202SEli Billauer *endpoint_alloc(struct xillyusb_dev *xdev,
489a53d1202SEli Billauer u8 ep_num,
490a53d1202SEli Billauer void (*work)(struct work_struct *),
491a53d1202SEli Billauer unsigned int order,
492a53d1202SEli Billauer int bufnum)
493a53d1202SEli Billauer {
494a53d1202SEli Billauer int i;
495a53d1202SEli Billauer
496a53d1202SEli Billauer struct xillyusb_endpoint *ep;
497a53d1202SEli Billauer
498a53d1202SEli Billauer ep = kzalloc(sizeof(*ep), GFP_KERNEL);
499a53d1202SEli Billauer
500a53d1202SEli Billauer if (!ep)
501a53d1202SEli Billauer return NULL;
502a53d1202SEli Billauer
503a53d1202SEli Billauer INIT_LIST_HEAD(&ep->buffers);
504a53d1202SEli Billauer INIT_LIST_HEAD(&ep->filled_buffers);
505a53d1202SEli Billauer
506a53d1202SEli Billauer spin_lock_init(&ep->buffers_lock);
507a53d1202SEli Billauer mutex_init(&ep->ep_mutex);
508a53d1202SEli Billauer
509a53d1202SEli Billauer init_usb_anchor(&ep->anchor);
510a53d1202SEli Billauer INIT_WORK(&ep->workitem, work);
511a53d1202SEli Billauer
512a53d1202SEli Billauer ep->order = order;
513a53d1202SEli Billauer ep->buffer_size = 1 << (PAGE_SHIFT + order);
514a53d1202SEli Billauer ep->outstanding_urbs = 0;
515a53d1202SEli Billauer ep->drained = true;
516a53d1202SEli Billauer ep->wake_on_drain = false;
517a53d1202SEli Billauer ep->xdev = xdev;
518a53d1202SEli Billauer ep->ep_num = ep_num;
519a53d1202SEli Billauer ep->shutting_down = false;
520a53d1202SEli Billauer
521a53d1202SEli Billauer for (i = 0; i < bufnum; i++) {
522a53d1202SEli Billauer struct xillybuffer *xb;
523a53d1202SEli Billauer unsigned long addr;
524a53d1202SEli Billauer
525a53d1202SEli Billauer xb = kzalloc(sizeof(*xb), GFP_KERNEL);
526a53d1202SEli Billauer
527a53d1202SEli Billauer if (!xb) {
528a53d1202SEli Billauer endpoint_dealloc(ep);
529a53d1202SEli Billauer return NULL;
530a53d1202SEli Billauer }
531a53d1202SEli Billauer
532a53d1202SEli Billauer addr = __get_free_pages(GFP_KERNEL, order);
533a53d1202SEli Billauer
534a53d1202SEli Billauer if (!addr) {
535a53d1202SEli Billauer kfree(xb);
536a53d1202SEli Billauer endpoint_dealloc(ep);
537a53d1202SEli Billauer return NULL;
538a53d1202SEli Billauer }
539a53d1202SEli Billauer
540a53d1202SEli Billauer xb->buf = (void *)addr;
541a53d1202SEli Billauer xb->ep = ep;
542a53d1202SEli Billauer list_add_tail(&xb->entry, &ep->buffers);
543a53d1202SEli Billauer }
544a53d1202SEli Billauer return ep;
545a53d1202SEli Billauer }
546a53d1202SEli Billauer
cleanup_dev(struct kref * kref)547a53d1202SEli Billauer static void cleanup_dev(struct kref *kref)
548a53d1202SEli Billauer {
549a53d1202SEli Billauer struct xillyusb_dev *xdev =
550a53d1202SEli Billauer container_of(kref, struct xillyusb_dev, kref);
551a53d1202SEli Billauer
552a53d1202SEli Billauer if (xdev->in_ep)
553a53d1202SEli Billauer endpoint_dealloc(xdev->in_ep);
554a53d1202SEli Billauer
555a53d1202SEli Billauer if (xdev->msg_ep)
556a53d1202SEli Billauer endpoint_dealloc(xdev->msg_ep);
557a53d1202SEli Billauer
558a53d1202SEli Billauer if (xdev->workq)
559a53d1202SEli Billauer destroy_workqueue(xdev->workq);
560a53d1202SEli Billauer
561b67d1966SHangyu Hua usb_put_dev(xdev->udev);
562a53d1202SEli Billauer kfree(xdev->channels); /* Argument may be NULL, and that's fine */
563a53d1202SEli Billauer kfree(xdev);
564a53d1202SEli Billauer }
565a53d1202SEli Billauer
566a53d1202SEli Billauer /*
567a53d1202SEli Billauer * @process_in_mutex is taken to ensure that bulk_in_work() won't call
568a53d1202SEli Billauer * process_bulk_in() after wakeup_all()'s execution: The latter zeroes all
569a53d1202SEli Billauer * @read_data_ok entries, which will make process_bulk_in() report false
570a53d1202SEli Billauer * errors if executed. The mechanism relies on that xdev->error is assigned
571a53d1202SEli Billauer * a non-zero value by report_io_error() prior to queueing wakeup_all(),
572a53d1202SEli Billauer * which prevents bulk_in_work() from calling process_bulk_in().
573a53d1202SEli Billauer */
574a53d1202SEli Billauer
wakeup_all(struct work_struct * work)575a53d1202SEli Billauer static void wakeup_all(struct work_struct *work)
576a53d1202SEli Billauer {
577a53d1202SEli Billauer int i;
578a53d1202SEli Billauer struct xillyusb_dev *xdev = container_of(work, struct xillyusb_dev,
579a53d1202SEli Billauer wakeup_workitem);
580a53d1202SEli Billauer
581a53d1202SEli Billauer mutex_lock(&xdev->process_in_mutex);
582a53d1202SEli Billauer
583a53d1202SEli Billauer for (i = 0; i < xdev->num_channels; i++) {
584a53d1202SEli Billauer struct xillyusb_channel *chan = &xdev->channels[i];
585a53d1202SEli Billauer
586a53d1202SEli Billauer mutex_lock(&chan->lock);
587a53d1202SEli Billauer
588a53d1202SEli Billauer if (chan->in_fifo) {
589a53d1202SEli Billauer /*
590a53d1202SEli Billauer * Fake an EOF: Even if such arrives, it won't be
591a53d1202SEli Billauer * processed.
592a53d1202SEli Billauer */
593a53d1202SEli Billauer chan->read_data_ok = 0;
594a53d1202SEli Billauer wake_up_interruptible(&chan->in_fifo->waitq);
595a53d1202SEli Billauer }
596a53d1202SEli Billauer
597a53d1202SEli Billauer if (chan->out_ep)
598a53d1202SEli Billauer wake_up_interruptible(&chan->out_ep->fifo.waitq);
599a53d1202SEli Billauer
600a53d1202SEli Billauer mutex_unlock(&chan->lock);
601a53d1202SEli Billauer
602a53d1202SEli Billauer wake_up_interruptible(&chan->flushq);
603a53d1202SEli Billauer }
604a53d1202SEli Billauer
605a53d1202SEli Billauer mutex_unlock(&xdev->process_in_mutex);
606a53d1202SEli Billauer
607a53d1202SEli Billauer wake_up_interruptible(&xdev->msg_ep->fifo.waitq);
608a53d1202SEli Billauer
609a53d1202SEli Billauer kref_put(&xdev->kref, cleanup_dev);
610a53d1202SEli Billauer }
611a53d1202SEli Billauer
report_io_error(struct xillyusb_dev * xdev,int errcode)612a53d1202SEli Billauer static void report_io_error(struct xillyusb_dev *xdev,
613a53d1202SEli Billauer int errcode)
614a53d1202SEli Billauer {
615a53d1202SEli Billauer unsigned long flags;
616a53d1202SEli Billauer bool do_once = false;
617a53d1202SEli Billauer
618a53d1202SEli Billauer spin_lock_irqsave(&xdev->error_lock, flags);
619a53d1202SEli Billauer if (!xdev->error) {
620a53d1202SEli Billauer xdev->error = errcode;
621a53d1202SEli Billauer do_once = true;
622a53d1202SEli Billauer }
623a53d1202SEli Billauer spin_unlock_irqrestore(&xdev->error_lock, flags);
624a53d1202SEli Billauer
625a53d1202SEli Billauer if (do_once) {
626a53d1202SEli Billauer kref_get(&xdev->kref); /* xdev is used by work item */
627a7ad105bSEli Billauer queue_work(wakeup_wq, &xdev->wakeup_workitem);
628a53d1202SEli Billauer }
629a53d1202SEli Billauer }
630a53d1202SEli Billauer
631a53d1202SEli Billauer /*
632a53d1202SEli Billauer * safely_assign_in_fifo() changes the value of chan->in_fifo and ensures
633a53d1202SEli Billauer * the previous pointer is never used after its return.
634a53d1202SEli Billauer */
635a53d1202SEli Billauer
safely_assign_in_fifo(struct xillyusb_channel * chan,struct xillyfifo * fifo)636a53d1202SEli Billauer static void safely_assign_in_fifo(struct xillyusb_channel *chan,
637a53d1202SEli Billauer struct xillyfifo *fifo)
638a53d1202SEli Billauer {
639a53d1202SEli Billauer mutex_lock(&chan->lock);
640a53d1202SEli Billauer chan->in_fifo = fifo;
641a53d1202SEli Billauer mutex_unlock(&chan->lock);
642a53d1202SEli Billauer
643a53d1202SEli Billauer flush_work(&chan->xdev->in_ep->workitem);
644a53d1202SEli Billauer }
645a53d1202SEli Billauer
bulk_in_completer(struct urb * urb)646a53d1202SEli Billauer static void bulk_in_completer(struct urb *urb)
647a53d1202SEli Billauer {
648a53d1202SEli Billauer struct xillybuffer *xb = urb->context;
649a53d1202SEli Billauer struct xillyusb_endpoint *ep = xb->ep;
650a53d1202SEli Billauer unsigned long flags;
651a53d1202SEli Billauer
652a53d1202SEli Billauer if (urb->status) {
653a53d1202SEli Billauer if (!(urb->status == -ENOENT ||
654a53d1202SEli Billauer urb->status == -ECONNRESET ||
655a53d1202SEli Billauer urb->status == -ESHUTDOWN))
656a53d1202SEli Billauer report_io_error(ep->xdev, -EIO);
657a53d1202SEli Billauer
658a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
659a53d1202SEli Billauer list_add_tail(&xb->entry, &ep->buffers);
660a53d1202SEli Billauer ep->outstanding_urbs--;
661a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
662a53d1202SEli Billauer
663a53d1202SEli Billauer return;
664a53d1202SEli Billauer }
665a53d1202SEli Billauer
666a53d1202SEli Billauer xb->len = urb->actual_length;
667a53d1202SEli Billauer
668a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
669a53d1202SEli Billauer list_add_tail(&xb->entry, &ep->filled_buffers);
670a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
671a53d1202SEli Billauer
672a53d1202SEli Billauer if (!ep->shutting_down)
673a53d1202SEli Billauer queue_work(ep->xdev->workq, &ep->workitem);
674a53d1202SEli Billauer }
675a53d1202SEli Billauer
bulk_out_completer(struct urb * urb)676a53d1202SEli Billauer static void bulk_out_completer(struct urb *urb)
677a53d1202SEli Billauer {
678a53d1202SEli Billauer struct xillybuffer *xb = urb->context;
679a53d1202SEli Billauer struct xillyusb_endpoint *ep = xb->ep;
680a53d1202SEli Billauer unsigned long flags;
681a53d1202SEli Billauer
682a53d1202SEli Billauer if (urb->status &&
683a53d1202SEli Billauer (!(urb->status == -ENOENT ||
684a53d1202SEli Billauer urb->status == -ECONNRESET ||
685a53d1202SEli Billauer urb->status == -ESHUTDOWN)))
686a53d1202SEli Billauer report_io_error(ep->xdev, -EIO);
687a53d1202SEli Billauer
688a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
689a53d1202SEli Billauer list_add_tail(&xb->entry, &ep->buffers);
690a53d1202SEli Billauer ep->outstanding_urbs--;
691a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
692a53d1202SEli Billauer
693a53d1202SEli Billauer if (!ep->shutting_down)
694a53d1202SEli Billauer queue_work(ep->xdev->workq, &ep->workitem);
695a53d1202SEli Billauer }
696a53d1202SEli Billauer
try_queue_bulk_in(struct xillyusb_endpoint * ep)697a53d1202SEli Billauer static void try_queue_bulk_in(struct xillyusb_endpoint *ep)
698a53d1202SEli Billauer {
699a53d1202SEli Billauer struct xillyusb_dev *xdev = ep->xdev;
700a53d1202SEli Billauer struct xillybuffer *xb;
701a53d1202SEli Billauer struct urb *urb;
702a53d1202SEli Billauer
703a53d1202SEli Billauer int rc;
704a53d1202SEli Billauer unsigned long flags;
705a53d1202SEli Billauer unsigned int bufsize = ep->buffer_size;
706a53d1202SEli Billauer
707a53d1202SEli Billauer mutex_lock(&ep->ep_mutex);
708a53d1202SEli Billauer
709a53d1202SEli Billauer if (ep->shutting_down || xdev->error)
710a53d1202SEli Billauer goto done;
711a53d1202SEli Billauer
712a53d1202SEli Billauer while (1) {
713a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
714a53d1202SEli Billauer
715a53d1202SEli Billauer if (list_empty(&ep->buffers)) {
716a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
717a53d1202SEli Billauer goto done;
718a53d1202SEli Billauer }
719a53d1202SEli Billauer
720a53d1202SEli Billauer xb = list_first_entry(&ep->buffers, struct xillybuffer, entry);
721a53d1202SEli Billauer list_del(&xb->entry);
722a53d1202SEli Billauer ep->outstanding_urbs++;
723a53d1202SEli Billauer
724a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
725a53d1202SEli Billauer
726a53d1202SEli Billauer urb = usb_alloc_urb(0, GFP_KERNEL);
727a53d1202SEli Billauer if (!urb) {
728a53d1202SEli Billauer report_io_error(xdev, -ENOMEM);
729a53d1202SEli Billauer goto relist;
730a53d1202SEli Billauer }
731a53d1202SEli Billauer
732a53d1202SEli Billauer usb_fill_bulk_urb(urb, xdev->udev,
733a53d1202SEli Billauer usb_rcvbulkpipe(xdev->udev, ep->ep_num),
734a53d1202SEli Billauer xb->buf, bufsize, bulk_in_completer, xb);
735a53d1202SEli Billauer
736a53d1202SEli Billauer usb_anchor_urb(urb, &ep->anchor);
737a53d1202SEli Billauer
738a53d1202SEli Billauer rc = usb_submit_urb(urb, GFP_KERNEL);
739a53d1202SEli Billauer
740a53d1202SEli Billauer if (rc) {
741a53d1202SEli Billauer report_io_error(xdev, (rc == -ENOMEM) ? -ENOMEM :
742a53d1202SEli Billauer -EIO);
743a53d1202SEli Billauer goto unanchor;
744a53d1202SEli Billauer }
745a53d1202SEli Billauer
746a53d1202SEli Billauer usb_free_urb(urb); /* This just decrements reference count */
747a53d1202SEli Billauer }
748a53d1202SEli Billauer
749a53d1202SEli Billauer unanchor:
750a53d1202SEli Billauer usb_unanchor_urb(urb);
751a53d1202SEli Billauer usb_free_urb(urb);
752a53d1202SEli Billauer
753a53d1202SEli Billauer relist:
754a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
755a53d1202SEli Billauer list_add_tail(&xb->entry, &ep->buffers);
756a53d1202SEli Billauer ep->outstanding_urbs--;
757a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
758a53d1202SEli Billauer
759a53d1202SEli Billauer done:
760a53d1202SEli Billauer mutex_unlock(&ep->ep_mutex);
761a53d1202SEli Billauer }
762a53d1202SEli Billauer
try_queue_bulk_out(struct xillyusb_endpoint * ep)763a53d1202SEli Billauer static void try_queue_bulk_out(struct xillyusb_endpoint *ep)
764a53d1202SEli Billauer {
765a53d1202SEli Billauer struct xillyfifo *fifo = &ep->fifo;
766a53d1202SEli Billauer struct xillyusb_dev *xdev = ep->xdev;
767a53d1202SEli Billauer struct xillybuffer *xb;
768a53d1202SEli Billauer struct urb *urb;
769a53d1202SEli Billauer
770a53d1202SEli Billauer int rc;
771a53d1202SEli Billauer unsigned int fill;
772a53d1202SEli Billauer unsigned long flags;
773a53d1202SEli Billauer bool do_wake = false;
774a53d1202SEli Billauer
775a53d1202SEli Billauer mutex_lock(&ep->ep_mutex);
776a53d1202SEli Billauer
777a53d1202SEli Billauer if (ep->shutting_down || xdev->error)
778a53d1202SEli Billauer goto done;
779a53d1202SEli Billauer
780a53d1202SEli Billauer fill = READ_ONCE(fifo->fill) & ep->fill_mask;
781a53d1202SEli Billauer
782a53d1202SEli Billauer while (1) {
783a53d1202SEli Billauer int count;
784a53d1202SEli Billauer unsigned int max_read;
785a53d1202SEli Billauer
786a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
787a53d1202SEli Billauer
788a53d1202SEli Billauer /*
789a53d1202SEli Billauer * Race conditions might have the FIFO filled while the
790a53d1202SEli Billauer * endpoint is marked as drained here. That doesn't matter,
791a53d1202SEli Billauer * because the sole purpose of @drained is to ensure that
792a53d1202SEli Billauer * certain data has been sent on the USB channel before
793a53d1202SEli Billauer * shutting it down. Hence knowing that the FIFO appears
794a53d1202SEli Billauer * to be empty with no outstanding URBs at some moment
795a53d1202SEli Billauer * is good enough.
796a53d1202SEli Billauer */
797a53d1202SEli Billauer
798a53d1202SEli Billauer if (!fill) {
799a53d1202SEli Billauer ep->drained = !ep->outstanding_urbs;
800a53d1202SEli Billauer if (ep->drained && ep->wake_on_drain)
801a53d1202SEli Billauer do_wake = true;
802a53d1202SEli Billauer
803a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
804a53d1202SEli Billauer goto done;
805a53d1202SEli Billauer }
806a53d1202SEli Billauer
807a53d1202SEli Billauer ep->drained = false;
808a53d1202SEli Billauer
809a53d1202SEli Billauer if ((fill < ep->buffer_size && ep->outstanding_urbs) ||
810a53d1202SEli Billauer list_empty(&ep->buffers)) {
811a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
812a53d1202SEli Billauer goto done;
813a53d1202SEli Billauer }
814a53d1202SEli Billauer
815a53d1202SEli Billauer xb = list_first_entry(&ep->buffers, struct xillybuffer, entry);
816a53d1202SEli Billauer list_del(&xb->entry);
817a53d1202SEli Billauer ep->outstanding_urbs++;
818a53d1202SEli Billauer
819a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
820a53d1202SEli Billauer
821a53d1202SEli Billauer max_read = min(fill, ep->buffer_size);
822a53d1202SEli Billauer
823a53d1202SEli Billauer count = fifo_read(&ep->fifo, xb->buf, max_read, xilly_memcpy);
824a53d1202SEli Billauer
825a53d1202SEli Billauer /*
826a53d1202SEli Billauer * xilly_memcpy always returns 0 => fifo_read can't fail =>
827a53d1202SEli Billauer * count > 0
828a53d1202SEli Billauer */
829a53d1202SEli Billauer
830a53d1202SEli Billauer urb = usb_alloc_urb(0, GFP_KERNEL);
831a53d1202SEli Billauer if (!urb) {
832a53d1202SEli Billauer report_io_error(xdev, -ENOMEM);
833a53d1202SEli Billauer goto relist;
834a53d1202SEli Billauer }
835a53d1202SEli Billauer
836a53d1202SEli Billauer usb_fill_bulk_urb(urb, xdev->udev,
837a53d1202SEli Billauer usb_sndbulkpipe(xdev->udev, ep->ep_num),
838a53d1202SEli Billauer xb->buf, count, bulk_out_completer, xb);
839a53d1202SEli Billauer
840a53d1202SEli Billauer usb_anchor_urb(urb, &ep->anchor);
841a53d1202SEli Billauer
842a53d1202SEli Billauer rc = usb_submit_urb(urb, GFP_KERNEL);
843a53d1202SEli Billauer
844a53d1202SEli Billauer if (rc) {
845a53d1202SEli Billauer report_io_error(xdev, (rc == -ENOMEM) ? -ENOMEM :
846a53d1202SEli Billauer -EIO);
847a53d1202SEli Billauer goto unanchor;
848a53d1202SEli Billauer }
849a53d1202SEli Billauer
850a53d1202SEli Billauer usb_free_urb(urb); /* This just decrements reference count */
851a53d1202SEli Billauer
852a53d1202SEli Billauer fill -= count;
853a53d1202SEli Billauer do_wake = true;
854a53d1202SEli Billauer }
855a53d1202SEli Billauer
856a53d1202SEli Billauer unanchor:
857a53d1202SEli Billauer usb_unanchor_urb(urb);
858a53d1202SEli Billauer usb_free_urb(urb);
859a53d1202SEli Billauer
860a53d1202SEli Billauer relist:
861a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
862a53d1202SEli Billauer list_add_tail(&xb->entry, &ep->buffers);
863a53d1202SEli Billauer ep->outstanding_urbs--;
864a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
865a53d1202SEli Billauer
866a53d1202SEli Billauer done:
867a53d1202SEli Billauer mutex_unlock(&ep->ep_mutex);
868a53d1202SEli Billauer
869a53d1202SEli Billauer if (do_wake)
870a53d1202SEli Billauer wake_up_interruptible(&fifo->waitq);
871a53d1202SEli Billauer }
872a53d1202SEli Billauer
bulk_out_work(struct work_struct * work)873a53d1202SEli Billauer static void bulk_out_work(struct work_struct *work)
874a53d1202SEli Billauer {
875a53d1202SEli Billauer struct xillyusb_endpoint *ep = container_of(work,
876a53d1202SEli Billauer struct xillyusb_endpoint,
877a53d1202SEli Billauer workitem);
878a53d1202SEli Billauer try_queue_bulk_out(ep);
879a53d1202SEli Billauer }
880a53d1202SEli Billauer
process_in_opcode(struct xillyusb_dev * xdev,int opcode,int chan_num)881a53d1202SEli Billauer static int process_in_opcode(struct xillyusb_dev *xdev,
882a53d1202SEli Billauer int opcode,
883a53d1202SEli Billauer int chan_num)
884a53d1202SEli Billauer {
885a53d1202SEli Billauer struct xillyusb_channel *chan;
886a53d1202SEli Billauer struct device *dev = xdev->dev;
887a53d1202SEli Billauer int chan_idx = chan_num >> 1;
888a53d1202SEli Billauer
889a53d1202SEli Billauer if (chan_idx >= xdev->num_channels) {
890a53d1202SEli Billauer dev_err(dev, "Received illegal channel ID %d from FPGA\n",
891a53d1202SEli Billauer chan_num);
892a53d1202SEli Billauer return -EIO;
893a53d1202SEli Billauer }
894a53d1202SEli Billauer
895a53d1202SEli Billauer chan = &xdev->channels[chan_idx];
896a53d1202SEli Billauer
897a53d1202SEli Billauer switch (opcode) {
898a53d1202SEli Billauer case OPCODE_EOF:
899a53d1202SEli Billauer if (!chan->read_data_ok) {
900a53d1202SEli Billauer dev_err(dev, "Received unexpected EOF for channel %d\n",
901a53d1202SEli Billauer chan_num);
902a53d1202SEli Billauer return -EIO;
903a53d1202SEli Billauer }
904a53d1202SEli Billauer
905a53d1202SEli Billauer /*
906a53d1202SEli Billauer * A write memory barrier ensures that the FIFO's fill level
907a53d1202SEli Billauer * is visible before read_data_ok turns zero, so the data in
908a53d1202SEli Billauer * the FIFO isn't missed by the consumer.
909a53d1202SEli Billauer */
910a53d1202SEli Billauer smp_wmb();
911a53d1202SEli Billauer WRITE_ONCE(chan->read_data_ok, 0);
912a53d1202SEli Billauer wake_up_interruptible(&chan->in_fifo->waitq);
913a53d1202SEli Billauer break;
914a53d1202SEli Billauer
915a53d1202SEli Billauer case OPCODE_REACHED_CHECKPOINT:
916a53d1202SEli Billauer chan->flushing = 0;
917a53d1202SEli Billauer wake_up_interruptible(&chan->flushq);
918a53d1202SEli Billauer break;
919a53d1202SEli Billauer
920a53d1202SEli Billauer case OPCODE_CANCELED_CHECKPOINT:
921a53d1202SEli Billauer chan->canceled = 1;
922a53d1202SEli Billauer wake_up_interruptible(&chan->flushq);
923a53d1202SEli Billauer break;
924a53d1202SEli Billauer
925a53d1202SEli Billauer default:
926a53d1202SEli Billauer dev_err(dev, "Received illegal opcode %d from FPGA\n",
927a53d1202SEli Billauer opcode);
928a53d1202SEli Billauer return -EIO;
929a53d1202SEli Billauer }
930a53d1202SEli Billauer
931a53d1202SEli Billauer return 0;
932a53d1202SEli Billauer }
933a53d1202SEli Billauer
process_bulk_in(struct xillybuffer * xb)934a53d1202SEli Billauer static int process_bulk_in(struct xillybuffer *xb)
935a53d1202SEli Billauer {
936a53d1202SEli Billauer struct xillyusb_endpoint *ep = xb->ep;
937a53d1202SEli Billauer struct xillyusb_dev *xdev = ep->xdev;
938a53d1202SEli Billauer struct device *dev = xdev->dev;
939a53d1202SEli Billauer int dws = xb->len >> 2;
940a53d1202SEli Billauer __le32 *p = xb->buf;
941a53d1202SEli Billauer u32 ctrlword;
942a53d1202SEli Billauer struct xillyusb_channel *chan;
943a53d1202SEli Billauer struct xillyfifo *fifo;
944a53d1202SEli Billauer int chan_num = 0, opcode;
945a53d1202SEli Billauer int chan_idx;
946a53d1202SEli Billauer int bytes, count, dwconsume;
947a53d1202SEli Billauer int in_bytes_left = 0;
948a53d1202SEli Billauer int rc;
949a53d1202SEli Billauer
950a53d1202SEli Billauer if ((dws << 2) != xb->len) {
951a53d1202SEli Billauer dev_err(dev, "Received BULK IN transfer with %d bytes, not a multiple of 4\n",
952a53d1202SEli Billauer xb->len);
953a53d1202SEli Billauer return -EIO;
954a53d1202SEli Billauer }
955a53d1202SEli Billauer
956a53d1202SEli Billauer if (xdev->in_bytes_left) {
957a53d1202SEli Billauer bytes = min(xdev->in_bytes_left, dws << 2);
958a53d1202SEli Billauer in_bytes_left = xdev->in_bytes_left - bytes;
959a53d1202SEli Billauer chan_num = xdev->leftover_chan_num;
960a53d1202SEli Billauer goto resume_leftovers;
961a53d1202SEli Billauer }
962a53d1202SEli Billauer
963a53d1202SEli Billauer while (dws) {
964a53d1202SEli Billauer ctrlword = le32_to_cpu(*p++);
965a53d1202SEli Billauer dws--;
966a53d1202SEli Billauer
967a53d1202SEli Billauer chan_num = ctrlword & 0xfff;
968a53d1202SEli Billauer count = (ctrlword >> 12) & 0x3ff;
969a53d1202SEli Billauer opcode = (ctrlword >> 24) & 0xf;
970a53d1202SEli Billauer
971a53d1202SEli Billauer if (opcode != OPCODE_DATA) {
972a53d1202SEli Billauer unsigned int in_counter = xdev->in_counter++ & 0x3ff;
973a53d1202SEli Billauer
974a53d1202SEli Billauer if (count != in_counter) {
975a53d1202SEli Billauer dev_err(dev, "Expected opcode counter %d, got %d\n",
976a53d1202SEli Billauer in_counter, count);
977a53d1202SEli Billauer return -EIO;
978a53d1202SEli Billauer }
979a53d1202SEli Billauer
980a53d1202SEli Billauer rc = process_in_opcode(xdev, opcode, chan_num);
981a53d1202SEli Billauer
982a53d1202SEli Billauer if (rc)
983a53d1202SEli Billauer return rc;
984a53d1202SEli Billauer
985a53d1202SEli Billauer continue;
986a53d1202SEli Billauer }
987a53d1202SEli Billauer
988a53d1202SEli Billauer bytes = min(count + 1, dws << 2);
989a53d1202SEli Billauer in_bytes_left = count + 1 - bytes;
990a53d1202SEli Billauer
991a53d1202SEli Billauer resume_leftovers:
992a53d1202SEli Billauer chan_idx = chan_num >> 1;
993a53d1202SEli Billauer
994a53d1202SEli Billauer if (!(chan_num & 1) || chan_idx >= xdev->num_channels ||
995a53d1202SEli Billauer !xdev->channels[chan_idx].read_data_ok) {
996a53d1202SEli Billauer dev_err(dev, "Received illegal channel ID %d from FPGA\n",
997a53d1202SEli Billauer chan_num);
998a53d1202SEli Billauer return -EIO;
999a53d1202SEli Billauer }
1000a53d1202SEli Billauer chan = &xdev->channels[chan_idx];
1001a53d1202SEli Billauer
1002a53d1202SEli Billauer fifo = chan->in_fifo;
1003a53d1202SEli Billauer
1004a53d1202SEli Billauer if (unlikely(!fifo))
1005a53d1202SEli Billauer return -EIO; /* We got really unexpected data */
1006a53d1202SEli Billauer
1007a53d1202SEli Billauer if (bytes != fifo_write(fifo, p, bytes, xilly_memcpy)) {
1008cc196fedSColin Ian King dev_err(dev, "Misbehaving FPGA overflowed an upstream FIFO!\n");
1009a53d1202SEli Billauer return -EIO;
1010a53d1202SEli Billauer }
1011a53d1202SEli Billauer
1012a53d1202SEli Billauer wake_up_interruptible(&fifo->waitq);
1013a53d1202SEli Billauer
1014a53d1202SEli Billauer dwconsume = (bytes + 3) >> 2;
1015a53d1202SEli Billauer dws -= dwconsume;
1016a53d1202SEli Billauer p += dwconsume;
1017a53d1202SEli Billauer }
1018a53d1202SEli Billauer
1019a53d1202SEli Billauer xdev->in_bytes_left = in_bytes_left;
1020a53d1202SEli Billauer xdev->leftover_chan_num = chan_num;
1021a53d1202SEli Billauer return 0;
1022a53d1202SEli Billauer }
1023a53d1202SEli Billauer
bulk_in_work(struct work_struct * work)1024a53d1202SEli Billauer static void bulk_in_work(struct work_struct *work)
1025a53d1202SEli Billauer {
1026a53d1202SEli Billauer struct xillyusb_endpoint *ep =
1027a53d1202SEli Billauer container_of(work, struct xillyusb_endpoint, workitem);
1028a53d1202SEli Billauer struct xillyusb_dev *xdev = ep->xdev;
1029a53d1202SEli Billauer unsigned long flags;
1030a53d1202SEli Billauer struct xillybuffer *xb;
1031a53d1202SEli Billauer bool consumed = false;
1032a53d1202SEli Billauer int rc = 0;
1033a53d1202SEli Billauer
1034a53d1202SEli Billauer mutex_lock(&xdev->process_in_mutex);
1035a53d1202SEli Billauer
1036a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
1037a53d1202SEli Billauer
1038a53d1202SEli Billauer while (1) {
1039a53d1202SEli Billauer if (rc || list_empty(&ep->filled_buffers)) {
1040a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
1041a53d1202SEli Billauer mutex_unlock(&xdev->process_in_mutex);
1042a53d1202SEli Billauer
1043a53d1202SEli Billauer if (rc)
1044a53d1202SEli Billauer report_io_error(xdev, rc);
1045a53d1202SEli Billauer else if (consumed)
1046a53d1202SEli Billauer try_queue_bulk_in(ep);
1047a53d1202SEli Billauer
1048a53d1202SEli Billauer return;
1049a53d1202SEli Billauer }
1050a53d1202SEli Billauer
1051a53d1202SEli Billauer xb = list_first_entry(&ep->filled_buffers, struct xillybuffer,
1052a53d1202SEli Billauer entry);
1053a53d1202SEli Billauer list_del(&xb->entry);
1054a53d1202SEli Billauer
1055a53d1202SEli Billauer spin_unlock_irqrestore(&ep->buffers_lock, flags);
1056a53d1202SEli Billauer
1057a53d1202SEli Billauer consumed = true;
1058a53d1202SEli Billauer
1059a53d1202SEli Billauer if (!xdev->error)
1060a53d1202SEli Billauer rc = process_bulk_in(xb);
1061a53d1202SEli Billauer
1062a53d1202SEli Billauer spin_lock_irqsave(&ep->buffers_lock, flags);
1063a53d1202SEli Billauer list_add_tail(&xb->entry, &ep->buffers);
1064a53d1202SEli Billauer ep->outstanding_urbs--;
1065a53d1202SEli Billauer }
1066a53d1202SEli Billauer }
1067a53d1202SEli Billauer
xillyusb_send_opcode(struct xillyusb_dev * xdev,int chan_num,char opcode,u32 data)1068a53d1202SEli Billauer static int xillyusb_send_opcode(struct xillyusb_dev *xdev,
1069a53d1202SEli Billauer int chan_num, char opcode, u32 data)
1070a53d1202SEli Billauer {
1071a53d1202SEli Billauer struct xillyusb_endpoint *ep = xdev->msg_ep;
1072a53d1202SEli Billauer struct xillyfifo *fifo = &ep->fifo;
1073a53d1202SEli Billauer __le32 msg[2];
1074a53d1202SEli Billauer
1075a53d1202SEli Billauer int rc = 0;
1076a53d1202SEli Billauer
1077a53d1202SEli Billauer msg[0] = cpu_to_le32((chan_num & 0xfff) |
1078a53d1202SEli Billauer ((opcode & 0xf) << 24));
1079a53d1202SEli Billauer msg[1] = cpu_to_le32(data);
1080a53d1202SEli Billauer
1081a53d1202SEli Billauer mutex_lock(&xdev->msg_mutex);
1082a53d1202SEli Billauer
1083a53d1202SEli Billauer /*
1084a53d1202SEli Billauer * The wait queue is woken with the interruptible variant, so the
1085a53d1202SEli Billauer * wait function matches, however returning because of an interrupt
1086a53d1202SEli Billauer * will mess things up considerably, in particular when the caller is
1087a53d1202SEli Billauer * the release method. And the xdev->error part prevents being stuck
1088a53d1202SEli Billauer * forever in the event of a bizarre hardware bug: Pull the USB plug.
1089a53d1202SEli Billauer */
1090a53d1202SEli Billauer
1091a53d1202SEli Billauer while (wait_event_interruptible(fifo->waitq,
1092a53d1202SEli Billauer fifo->fill <= (fifo->size - 8) ||
1093a53d1202SEli Billauer xdev->error))
1094a53d1202SEli Billauer ; /* Empty loop */
1095a53d1202SEli Billauer
1096a53d1202SEli Billauer if (xdev->error) {
1097a53d1202SEli Billauer rc = xdev->error;
1098a53d1202SEli Billauer goto unlock_done;
1099a53d1202SEli Billauer }
1100a53d1202SEli Billauer
1101a53d1202SEli Billauer fifo_write(fifo, (void *)msg, 8, xilly_memcpy);
1102a53d1202SEli Billauer
1103a53d1202SEli Billauer try_queue_bulk_out(ep);
1104a53d1202SEli Billauer
1105a53d1202SEli Billauer unlock_done:
1106a53d1202SEli Billauer mutex_unlock(&xdev->msg_mutex);
1107a53d1202SEli Billauer
1108a53d1202SEli Billauer return rc;
1109a53d1202SEli Billauer }
1110a53d1202SEli Billauer
1111a53d1202SEli Billauer /*
1112a53d1202SEli Billauer * Note that flush_downstream() merely waits for the data to arrive to
1113a53d1202SEli Billauer * the application logic at the FPGA -- unlike PCIe Xillybus' counterpart,
1114a53d1202SEli Billauer * it does nothing to make it happen (and neither is it necessary).
1115a53d1202SEli Billauer *
1116a53d1202SEli Billauer * This function is not reentrant for the same @chan, but this is covered
1117a53d1202SEli Billauer * by the fact that for any given @chan, it's called either by the open,
1118a53d1202SEli Billauer * write, llseek and flush fops methods, which can't run in parallel (and the
1119a53d1202SEli Billauer * write + flush and llseek method handlers are protected with out_mutex).
1120a53d1202SEli Billauer *
1121a53d1202SEli Billauer * chan->flushed is there to avoid multiple flushes at the same position,
1122a53d1202SEli Billauer * in particular as a result of programs that close the file descriptor
1123a53d1202SEli Billauer * e.g. after a dup2() for redirection.
1124a53d1202SEli Billauer */
1125a53d1202SEli Billauer
flush_downstream(struct xillyusb_channel * chan,long timeout,bool interruptible)1126a53d1202SEli Billauer static int flush_downstream(struct xillyusb_channel *chan,
1127a53d1202SEli Billauer long timeout,
1128a53d1202SEli Billauer bool interruptible)
1129a53d1202SEli Billauer {
1130a53d1202SEli Billauer struct xillyusb_dev *xdev = chan->xdev;
1131a53d1202SEli Billauer int chan_num = chan->chan_idx << 1;
1132a53d1202SEli Billauer long deadline, left_to_sleep;
1133a53d1202SEli Billauer int rc;
1134a53d1202SEli Billauer
1135a53d1202SEli Billauer if (chan->flushed)
1136a53d1202SEli Billauer return 0;
1137a53d1202SEli Billauer
1138a53d1202SEli Billauer deadline = jiffies + 1 + timeout;
1139a53d1202SEli Billauer
1140a53d1202SEli Billauer if (chan->flushing) {
1141a53d1202SEli Billauer long cancel_deadline = jiffies + 1 + XILLY_RESPONSE_TIMEOUT;
1142a53d1202SEli Billauer
1143a53d1202SEli Billauer chan->canceled = 0;
1144a53d1202SEli Billauer rc = xillyusb_send_opcode(xdev, chan_num,
1145a53d1202SEli Billauer OPCODE_CANCEL_CHECKPOINT, 0);
1146a53d1202SEli Billauer
1147a53d1202SEli Billauer if (rc)
1148a53d1202SEli Billauer return rc; /* Only real error, never -EINTR */
1149a53d1202SEli Billauer
1150a53d1202SEli Billauer /* Ignoring interrupts. Cancellation must be handled */
1151a53d1202SEli Billauer while (!chan->canceled) {
1152a53d1202SEli Billauer left_to_sleep = cancel_deadline - ((long)jiffies);
1153a53d1202SEli Billauer
1154a53d1202SEli Billauer if (left_to_sleep <= 0) {
1155a53d1202SEli Billauer report_io_error(xdev, -EIO);
1156a53d1202SEli Billauer return -EIO;
1157a53d1202SEli Billauer }
1158a53d1202SEli Billauer
1159a53d1202SEli Billauer rc = wait_event_interruptible_timeout(chan->flushq,
1160a53d1202SEli Billauer chan->canceled ||
1161a53d1202SEli Billauer xdev->error,
1162a53d1202SEli Billauer left_to_sleep);
1163a53d1202SEli Billauer
1164a53d1202SEli Billauer if (xdev->error)
1165a53d1202SEli Billauer return xdev->error;
1166a53d1202SEli Billauer }
1167a53d1202SEli Billauer }
1168a53d1202SEli Billauer
1169a53d1202SEli Billauer chan->flushing = 1;
1170a53d1202SEli Billauer
1171a53d1202SEli Billauer /*
1172a53d1202SEli Billauer * The checkpoint is given in terms of data elements, not bytes. As
1173a53d1202SEli Billauer * a result, if less than an element's worth of data is stored in the
1174a53d1202SEli Billauer * FIFO, it's not flushed, including the flush before closing, which
1175a53d1202SEli Billauer * means that such data is lost. This is consistent with PCIe Xillybus.
1176a53d1202SEli Billauer */
1177a53d1202SEli Billauer
1178a53d1202SEli Billauer rc = xillyusb_send_opcode(xdev, chan_num,
1179a53d1202SEli Billauer OPCODE_SET_CHECKPOINT,
1180a53d1202SEli Billauer chan->out_bytes >>
1181a53d1202SEli Billauer chan->out_log2_element_size);
1182a53d1202SEli Billauer
1183a53d1202SEli Billauer if (rc)
1184a53d1202SEli Billauer return rc; /* Only real error, never -EINTR */
1185a53d1202SEli Billauer
1186a53d1202SEli Billauer if (!timeout) {
1187a53d1202SEli Billauer while (chan->flushing) {
1188a53d1202SEli Billauer rc = wait_event_interruptible(chan->flushq,
1189a53d1202SEli Billauer !chan->flushing ||
1190a53d1202SEli Billauer xdev->error);
1191a53d1202SEli Billauer if (xdev->error)
1192a53d1202SEli Billauer return xdev->error;
1193a53d1202SEli Billauer
1194a53d1202SEli Billauer if (interruptible && rc)
1195a53d1202SEli Billauer return -EINTR;
1196a53d1202SEli Billauer }
1197a53d1202SEli Billauer
1198a53d1202SEli Billauer goto done;
1199a53d1202SEli Billauer }
1200a53d1202SEli Billauer
1201a53d1202SEli Billauer while (chan->flushing) {
1202a53d1202SEli Billauer left_to_sleep = deadline - ((long)jiffies);
1203a53d1202SEli Billauer
1204a53d1202SEli Billauer if (left_to_sleep <= 0)
1205a53d1202SEli Billauer return -ETIMEDOUT;
1206a53d1202SEli Billauer
1207a53d1202SEli Billauer rc = wait_event_interruptible_timeout(chan->flushq,
1208a53d1202SEli Billauer !chan->flushing ||
1209a53d1202SEli Billauer xdev->error,
1210a53d1202SEli Billauer left_to_sleep);
1211a53d1202SEli Billauer
1212a53d1202SEli Billauer if (xdev->error)
1213a53d1202SEli Billauer return xdev->error;
1214a53d1202SEli Billauer
1215a53d1202SEli Billauer if (interruptible && rc < 0)
1216a53d1202SEli Billauer return -EINTR;
1217a53d1202SEli Billauer }
1218a53d1202SEli Billauer
1219a53d1202SEli Billauer done:
1220a53d1202SEli Billauer chan->flushed = 1;
1221a53d1202SEli Billauer return 0;
1222a53d1202SEli Billauer }
1223a53d1202SEli Billauer
1224a53d1202SEli Billauer /* request_read_anything(): Ask the FPGA for any little amount of data */
request_read_anything(struct xillyusb_channel * chan,char opcode)1225a53d1202SEli Billauer static int request_read_anything(struct xillyusb_channel *chan,
1226a53d1202SEli Billauer char opcode)
1227a53d1202SEli Billauer {
1228a53d1202SEli Billauer struct xillyusb_dev *xdev = chan->xdev;
1229a53d1202SEli Billauer unsigned int sh = chan->in_log2_element_size;
1230a53d1202SEli Billauer int chan_num = (chan->chan_idx << 1) | 1;
1231a53d1202SEli Billauer u32 mercy = chan->in_consumed_bytes + (2 << sh) - 1;
1232a53d1202SEli Billauer
1233a53d1202SEli Billauer return xillyusb_send_opcode(xdev, chan_num, opcode, mercy >> sh);
1234a53d1202SEli Billauer }
1235a53d1202SEli Billauer
xillyusb_open(struct inode * inode,struct file * filp)1236a53d1202SEli Billauer static int xillyusb_open(struct inode *inode, struct file *filp)
1237a53d1202SEli Billauer {
1238a53d1202SEli Billauer struct xillyusb_dev *xdev;
1239a53d1202SEli Billauer struct xillyusb_channel *chan;
1240a53d1202SEli Billauer struct xillyfifo *in_fifo = NULL;
1241a53d1202SEli Billauer struct xillyusb_endpoint *out_ep = NULL;
1242a53d1202SEli Billauer int rc;
1243a53d1202SEli Billauer int index;
1244a53d1202SEli Billauer
1245282a4b71SEli Billauer mutex_lock(&kref_mutex);
1246282a4b71SEli Billauer
1247a53d1202SEli Billauer rc = xillybus_find_inode(inode, (void **)&xdev, &index);
1248282a4b71SEli Billauer if (rc) {
1249282a4b71SEli Billauer mutex_unlock(&kref_mutex);
1250a53d1202SEli Billauer return rc;
1251282a4b71SEli Billauer }
1252282a4b71SEli Billauer
1253282a4b71SEli Billauer kref_get(&xdev->kref);
1254282a4b71SEli Billauer mutex_unlock(&kref_mutex);
1255a53d1202SEli Billauer
1256a53d1202SEli Billauer chan = &xdev->channels[index];
1257a53d1202SEli Billauer filp->private_data = chan;
1258a53d1202SEli Billauer
1259a53d1202SEli Billauer mutex_lock(&chan->lock);
1260a53d1202SEli Billauer
1261a53d1202SEli Billauer rc = -ENODEV;
1262a53d1202SEli Billauer
1263a53d1202SEli Billauer if (xdev->error)
1264a53d1202SEli Billauer goto unmutex_fail;
1265a53d1202SEli Billauer
1266a53d1202SEli Billauer if (((filp->f_mode & FMODE_READ) && !chan->readable) ||
1267a53d1202SEli Billauer ((filp->f_mode & FMODE_WRITE) && !chan->writable))
1268a53d1202SEli Billauer goto unmutex_fail;
1269a53d1202SEli Billauer
1270a53d1202SEli Billauer if ((filp->f_flags & O_NONBLOCK) && (filp->f_mode & FMODE_READ) &&
1271a53d1202SEli Billauer chan->in_synchronous) {
1272a53d1202SEli Billauer dev_err(xdev->dev,
1273a53d1202SEli Billauer "open() failed: O_NONBLOCK not allowed for read on this device\n");
1274a53d1202SEli Billauer goto unmutex_fail;
1275a53d1202SEli Billauer }
1276a53d1202SEli Billauer
1277a53d1202SEli Billauer if ((filp->f_flags & O_NONBLOCK) && (filp->f_mode & FMODE_WRITE) &&
1278a53d1202SEli Billauer chan->out_synchronous) {
1279a53d1202SEli Billauer dev_err(xdev->dev,
1280a53d1202SEli Billauer "open() failed: O_NONBLOCK not allowed for write on this device\n");
1281a53d1202SEli Billauer goto unmutex_fail;
1282a53d1202SEli Billauer }
1283a53d1202SEli Billauer
1284a53d1202SEli Billauer rc = -EBUSY;
1285a53d1202SEli Billauer
1286a53d1202SEli Billauer if (((filp->f_mode & FMODE_READ) && chan->open_for_read) ||
1287a53d1202SEli Billauer ((filp->f_mode & FMODE_WRITE) && chan->open_for_write))
1288a53d1202SEli Billauer goto unmutex_fail;
1289a53d1202SEli Billauer
1290a53d1202SEli Billauer if (filp->f_mode & FMODE_READ)
1291a53d1202SEli Billauer chan->open_for_read = 1;
1292a53d1202SEli Billauer
1293a53d1202SEli Billauer if (filp->f_mode & FMODE_WRITE)
1294a53d1202SEli Billauer chan->open_for_write = 1;
1295a53d1202SEli Billauer
1296a53d1202SEli Billauer mutex_unlock(&chan->lock);
1297a53d1202SEli Billauer
1298a53d1202SEli Billauer if (filp->f_mode & FMODE_WRITE) {
1299a53d1202SEli Billauer out_ep = endpoint_alloc(xdev,
1300a53d1202SEli Billauer (chan->chan_idx + 2) | USB_DIR_OUT,
1301a53d1202SEli Billauer bulk_out_work, BUF_SIZE_ORDER, BUFNUM);
1302a53d1202SEli Billauer
1303a53d1202SEli Billauer if (!out_ep) {
1304a53d1202SEli Billauer rc = -ENOMEM;
1305a53d1202SEli Billauer goto unopen;
1306a53d1202SEli Billauer }
1307a53d1202SEli Billauer
1308a53d1202SEli Billauer rc = fifo_init(&out_ep->fifo, chan->out_log2_fifo_size);
1309a53d1202SEli Billauer
1310a53d1202SEli Billauer if (rc)
1311a53d1202SEli Billauer goto late_unopen;
1312a53d1202SEli Billauer
1313a53d1202SEli Billauer out_ep->fill_mask = -(1 << chan->out_log2_element_size);
1314a53d1202SEli Billauer chan->out_bytes = 0;
1315a53d1202SEli Billauer chan->flushed = 0;
1316a53d1202SEli Billauer
1317a53d1202SEli Billauer /*
1318a53d1202SEli Billauer * Sending a flush request to a previously closed stream
1319a53d1202SEli Billauer * effectively opens it, and also waits until the command is
1320a53d1202SEli Billauer * confirmed by the FPGA. The latter is necessary because the
1321a53d1202SEli Billauer * data is sent through a separate BULK OUT endpoint, and the
1322a53d1202SEli Billauer * xHCI controller is free to reorder transmissions.
1323a53d1202SEli Billauer *
1324a53d1202SEli Billauer * This can't go wrong unless there's a serious hardware error
1325a53d1202SEli Billauer * (or the computer is stuck for 500 ms?)
1326a53d1202SEli Billauer */
1327a53d1202SEli Billauer rc = flush_downstream(chan, XILLY_RESPONSE_TIMEOUT, false);
1328a53d1202SEli Billauer
1329a53d1202SEli Billauer if (rc == -ETIMEDOUT) {
1330a53d1202SEli Billauer rc = -EIO;
1331a53d1202SEli Billauer report_io_error(xdev, rc);
1332a53d1202SEli Billauer }
1333a53d1202SEli Billauer
1334a53d1202SEli Billauer if (rc)
1335a53d1202SEli Billauer goto late_unopen;
1336a53d1202SEli Billauer }
1337a53d1202SEli Billauer
1338a53d1202SEli Billauer if (filp->f_mode & FMODE_READ) {
1339a53d1202SEli Billauer in_fifo = kzalloc(sizeof(*in_fifo), GFP_KERNEL);
1340a53d1202SEli Billauer
1341a53d1202SEli Billauer if (!in_fifo) {
1342a53d1202SEli Billauer rc = -ENOMEM;
1343a53d1202SEli Billauer goto late_unopen;
1344a53d1202SEli Billauer }
1345a53d1202SEli Billauer
1346a53d1202SEli Billauer rc = fifo_init(in_fifo, chan->in_log2_fifo_size);
1347a53d1202SEli Billauer
1348a53d1202SEli Billauer if (rc) {
1349a53d1202SEli Billauer kfree(in_fifo);
1350a53d1202SEli Billauer goto late_unopen;
1351a53d1202SEli Billauer }
1352a53d1202SEli Billauer }
1353a53d1202SEli Billauer
1354a53d1202SEli Billauer mutex_lock(&chan->lock);
1355a53d1202SEli Billauer if (in_fifo) {
1356a53d1202SEli Billauer chan->in_fifo = in_fifo;
1357a53d1202SEli Billauer chan->read_data_ok = 1;
1358a53d1202SEli Billauer }
1359a53d1202SEli Billauer if (out_ep)
1360a53d1202SEli Billauer chan->out_ep = out_ep;
1361a53d1202SEli Billauer mutex_unlock(&chan->lock);
1362a53d1202SEli Billauer
1363a53d1202SEli Billauer if (in_fifo) {
1364a53d1202SEli Billauer u32 in_checkpoint = 0;
1365a53d1202SEli Billauer
1366a53d1202SEli Billauer if (!chan->in_synchronous)
1367a53d1202SEli Billauer in_checkpoint = in_fifo->size >>
1368a53d1202SEli Billauer chan->in_log2_element_size;
1369a53d1202SEli Billauer
1370a53d1202SEli Billauer chan->in_consumed_bytes = 0;
1371a53d1202SEli Billauer chan->poll_used = 0;
1372a53d1202SEli Billauer chan->in_current_checkpoint = in_checkpoint;
1373a53d1202SEli Billauer rc = xillyusb_send_opcode(xdev, (chan->chan_idx << 1) | 1,
1374a53d1202SEli Billauer OPCODE_SET_CHECKPOINT,
1375a53d1202SEli Billauer in_checkpoint);
1376a53d1202SEli Billauer
1377a53d1202SEli Billauer if (rc) /* Failure guarantees that opcode wasn't sent */
1378a53d1202SEli Billauer goto unfifo;
1379a53d1202SEli Billauer
1380a53d1202SEli Billauer /*
1381a53d1202SEli Billauer * In non-blocking mode, request the FPGA to send any data it
1382a53d1202SEli Billauer * has right away. Otherwise, the first read() will always
1383a53d1202SEli Billauer * return -EAGAIN, which is OK strictly speaking, but ugly.
1384a53d1202SEli Billauer * Checking and unrolling if this fails isn't worth the
1385a53d1202SEli Billauer * effort -- the error is propagated to the first read()
1386a53d1202SEli Billauer * anyhow.
1387a53d1202SEli Billauer */
1388a53d1202SEli Billauer if (filp->f_flags & O_NONBLOCK)
1389a53d1202SEli Billauer request_read_anything(chan, OPCODE_SET_PUSH);
1390a53d1202SEli Billauer }
1391a53d1202SEli Billauer
1392a53d1202SEli Billauer return 0;
1393a53d1202SEli Billauer
1394a53d1202SEli Billauer unfifo:
1395a53d1202SEli Billauer chan->read_data_ok = 0;
1396a53d1202SEli Billauer safely_assign_in_fifo(chan, NULL);
1397a53d1202SEli Billauer fifo_mem_release(in_fifo);
1398a53d1202SEli Billauer kfree(in_fifo);
1399a53d1202SEli Billauer
1400a53d1202SEli Billauer if (out_ep) {
1401a53d1202SEli Billauer mutex_lock(&chan->lock);
1402a53d1202SEli Billauer chan->out_ep = NULL;
1403a53d1202SEli Billauer mutex_unlock(&chan->lock);
1404a53d1202SEli Billauer }
1405a53d1202SEli Billauer
1406a53d1202SEli Billauer late_unopen:
1407a53d1202SEli Billauer if (out_ep)
1408a53d1202SEli Billauer endpoint_dealloc(out_ep);
1409a53d1202SEli Billauer
1410a53d1202SEli Billauer unopen:
1411a53d1202SEli Billauer mutex_lock(&chan->lock);
1412a53d1202SEli Billauer
1413a53d1202SEli Billauer if (filp->f_mode & FMODE_READ)
1414a53d1202SEli Billauer chan->open_for_read = 0;
1415a53d1202SEli Billauer
1416a53d1202SEli Billauer if (filp->f_mode & FMODE_WRITE)
1417a53d1202SEli Billauer chan->open_for_write = 0;
1418a53d1202SEli Billauer
1419a53d1202SEli Billauer mutex_unlock(&chan->lock);
1420a53d1202SEli Billauer
1421a53d1202SEli Billauer kref_put(&xdev->kref, cleanup_dev);
1422a53d1202SEli Billauer
1423a53d1202SEli Billauer return rc;
1424a53d1202SEli Billauer
1425a53d1202SEli Billauer unmutex_fail:
1426282a4b71SEli Billauer kref_put(&xdev->kref, cleanup_dev);
1427a53d1202SEli Billauer mutex_unlock(&chan->lock);
1428a53d1202SEli Billauer return rc;
1429a53d1202SEli Billauer }
1430a53d1202SEli Billauer
xillyusb_read(struct file * filp,char __user * userbuf,size_t count,loff_t * f_pos)1431a53d1202SEli Billauer static ssize_t xillyusb_read(struct file *filp, char __user *userbuf,
1432a53d1202SEli Billauer size_t count, loff_t *f_pos)
1433a53d1202SEli Billauer {
1434a53d1202SEli Billauer struct xillyusb_channel *chan = filp->private_data;
1435a53d1202SEli Billauer struct xillyusb_dev *xdev = chan->xdev;
1436a53d1202SEli Billauer struct xillyfifo *fifo = chan->in_fifo;
1437a53d1202SEli Billauer int chan_num = (chan->chan_idx << 1) | 1;
1438a53d1202SEli Billauer
1439a53d1202SEli Billauer long deadline, left_to_sleep;
1440a53d1202SEli Billauer int bytes_done = 0;
1441a53d1202SEli Billauer bool sent_set_push = false;
1442a53d1202SEli Billauer int rc;
1443a53d1202SEli Billauer
1444a53d1202SEli Billauer deadline = jiffies + 1 + XILLY_RX_TIMEOUT;
1445a53d1202SEli Billauer
1446a53d1202SEli Billauer rc = mutex_lock_interruptible(&chan->in_mutex);
1447a53d1202SEli Billauer
1448a53d1202SEli Billauer if (rc)
1449a53d1202SEli Billauer return rc;
1450a53d1202SEli Billauer
1451a53d1202SEli Billauer while (1) {
1452a53d1202SEli Billauer u32 fifo_checkpoint_bytes, complete_checkpoint_bytes;
1453a53d1202SEli Billauer u32 complete_checkpoint, fifo_checkpoint;
1454a53d1202SEli Billauer u32 checkpoint;
1455a53d1202SEli Billauer s32 diff, leap;
1456a53d1202SEli Billauer unsigned int sh = chan->in_log2_element_size;
1457a53d1202SEli Billauer bool checkpoint_for_complete;
1458a53d1202SEli Billauer
1459a53d1202SEli Billauer rc = fifo_read(fifo, (__force void *)userbuf + bytes_done,
1460a53d1202SEli Billauer count - bytes_done, xilly_copy_to_user);
1461a53d1202SEli Billauer
1462a53d1202SEli Billauer if (rc < 0)
1463a53d1202SEli Billauer break;
1464a53d1202SEli Billauer
1465a53d1202SEli Billauer bytes_done += rc;
1466a53d1202SEli Billauer chan->in_consumed_bytes += rc;
1467a53d1202SEli Billauer
1468a53d1202SEli Billauer left_to_sleep = deadline - ((long)jiffies);
1469a53d1202SEli Billauer
1470a53d1202SEli Billauer /*
1471a53d1202SEli Billauer * Some 32-bit arithmetic that may wrap. Note that
1472a53d1202SEli Billauer * complete_checkpoint is rounded up to the closest element
1473a53d1202SEli Billauer * boundary, because the read() can't be completed otherwise.
1474a53d1202SEli Billauer * fifo_checkpoint_bytes is rounded down, because it protects
1475a53d1202SEli Billauer * in_fifo from overflowing.
1476a53d1202SEli Billauer */
1477a53d1202SEli Billauer
1478a53d1202SEli Billauer fifo_checkpoint_bytes = chan->in_consumed_bytes + fifo->size;
1479a53d1202SEli Billauer complete_checkpoint_bytes =
1480a53d1202SEli Billauer chan->in_consumed_bytes + count - bytes_done;
1481a53d1202SEli Billauer
1482a53d1202SEli Billauer fifo_checkpoint = fifo_checkpoint_bytes >> sh;
1483a53d1202SEli Billauer complete_checkpoint =
1484a53d1202SEli Billauer (complete_checkpoint_bytes + (1 << sh) - 1) >> sh;
1485a53d1202SEli Billauer
1486a53d1202SEli Billauer diff = (fifo_checkpoint - complete_checkpoint) << sh;
1487a53d1202SEli Billauer
1488a53d1202SEli Billauer if (chan->in_synchronous && diff >= 0) {
1489a53d1202SEli Billauer checkpoint = complete_checkpoint;
1490a53d1202SEli Billauer checkpoint_for_complete = true;
1491a53d1202SEli Billauer } else {
1492a53d1202SEli Billauer checkpoint = fifo_checkpoint;
1493a53d1202SEli Billauer checkpoint_for_complete = false;
1494a53d1202SEli Billauer }
1495a53d1202SEli Billauer
1496a53d1202SEli Billauer leap = (checkpoint - chan->in_current_checkpoint) << sh;
1497a53d1202SEli Billauer
1498a53d1202SEli Billauer /*
1499a53d1202SEli Billauer * To prevent flooding of OPCODE_SET_CHECKPOINT commands as
1500a53d1202SEli Billauer * data is consumed, it's issued only if it moves the
1501a53d1202SEli Billauer * checkpoint by at least an 8th of the FIFO's size, or if
1502a53d1202SEli Billauer * it's necessary to complete the number of bytes requested by
1503a53d1202SEli Billauer * the read() call.
1504a53d1202SEli Billauer *
1505a53d1202SEli Billauer * chan->read_data_ok is checked to spare an unnecessary
1506a53d1202SEli Billauer * submission after receiving EOF, however it's harmless if
1507a53d1202SEli Billauer * such slips away.
1508a53d1202SEli Billauer */
1509a53d1202SEli Billauer
1510a53d1202SEli Billauer if (chan->read_data_ok &&
1511a53d1202SEli Billauer (leap > (fifo->size >> 3) ||
1512a53d1202SEli Billauer (checkpoint_for_complete && leap > 0))) {
1513a53d1202SEli Billauer chan->in_current_checkpoint = checkpoint;
1514a53d1202SEli Billauer rc = xillyusb_send_opcode(xdev, chan_num,
1515a53d1202SEli Billauer OPCODE_SET_CHECKPOINT,
1516a53d1202SEli Billauer checkpoint);
1517a53d1202SEli Billauer
1518a53d1202SEli Billauer if (rc)
1519a53d1202SEli Billauer break;
1520a53d1202SEli Billauer }
1521a53d1202SEli Billauer
1522a53d1202SEli Billauer if (bytes_done == count ||
1523a53d1202SEli Billauer (left_to_sleep <= 0 && bytes_done))
1524a53d1202SEli Billauer break;
1525a53d1202SEli Billauer
1526a53d1202SEli Billauer /*
1527a53d1202SEli Billauer * Reaching here means that the FIFO was empty when
1528a53d1202SEli Billauer * fifo_read() returned, but not necessarily right now. Error
1529a53d1202SEli Billauer * and EOF are checked and reported only now, so that no data
1530a53d1202SEli Billauer * that managed its way to the FIFO is lost.
1531a53d1202SEli Billauer */
1532a53d1202SEli Billauer
1533a53d1202SEli Billauer if (!READ_ONCE(chan->read_data_ok)) { /* FPGA has sent EOF */
1534a53d1202SEli Billauer /* Has data slipped into the FIFO since fifo_read()? */
1535a53d1202SEli Billauer smp_rmb();
1536a53d1202SEli Billauer if (READ_ONCE(fifo->fill))
1537a53d1202SEli Billauer continue;
1538a53d1202SEli Billauer
1539a53d1202SEli Billauer rc = 0;
1540a53d1202SEli Billauer break;
1541a53d1202SEli Billauer }
1542a53d1202SEli Billauer
1543a53d1202SEli Billauer if (xdev->error) {
1544a53d1202SEli Billauer rc = xdev->error;
1545a53d1202SEli Billauer break;
1546a53d1202SEli Billauer }
1547a53d1202SEli Billauer
1548a53d1202SEli Billauer if (filp->f_flags & O_NONBLOCK) {
1549a53d1202SEli Billauer rc = -EAGAIN;
1550a53d1202SEli Billauer break;
1551a53d1202SEli Billauer }
1552a53d1202SEli Billauer
1553a53d1202SEli Billauer if (!sent_set_push) {
1554a53d1202SEli Billauer rc = xillyusb_send_opcode(xdev, chan_num,
1555a53d1202SEli Billauer OPCODE_SET_PUSH,
1556a53d1202SEli Billauer complete_checkpoint);
1557a53d1202SEli Billauer
1558a53d1202SEli Billauer if (rc)
1559a53d1202SEli Billauer break;
1560a53d1202SEli Billauer
1561a53d1202SEli Billauer sent_set_push = true;
1562a53d1202SEli Billauer }
1563a53d1202SEli Billauer
1564a53d1202SEli Billauer if (left_to_sleep > 0) {
1565a53d1202SEli Billauer /*
1566a53d1202SEli Billauer * Note that when xdev->error is set (e.g. when the
1567a53d1202SEli Billauer * device is unplugged), read_data_ok turns zero and
1568a53d1202SEli Billauer * fifo->waitq is awaken.
1569a53d1202SEli Billauer * Therefore no special attention to xdev->error.
1570a53d1202SEli Billauer */
1571a53d1202SEli Billauer
1572a53d1202SEli Billauer rc = wait_event_interruptible_timeout
1573a53d1202SEli Billauer (fifo->waitq,
1574a53d1202SEli Billauer fifo->fill || !chan->read_data_ok,
1575a53d1202SEli Billauer left_to_sleep);
1576a53d1202SEli Billauer } else { /* bytes_done == 0 */
1577a53d1202SEli Billauer /* Tell FPGA to send anything it has */
1578a53d1202SEli Billauer rc = request_read_anything(chan, OPCODE_UPDATE_PUSH);
1579a53d1202SEli Billauer
1580a53d1202SEli Billauer if (rc)
1581a53d1202SEli Billauer break;
1582a53d1202SEli Billauer
1583a53d1202SEli Billauer rc = wait_event_interruptible
1584a53d1202SEli Billauer (fifo->waitq,
1585a53d1202SEli Billauer fifo->fill || !chan->read_data_ok);
1586a53d1202SEli Billauer }
1587a53d1202SEli Billauer
1588a53d1202SEli Billauer if (rc < 0) {
1589a53d1202SEli Billauer rc = -EINTR;
1590a53d1202SEli Billauer break;
1591a53d1202SEli Billauer }
1592a53d1202SEli Billauer }
1593a53d1202SEli Billauer
1594a53d1202SEli Billauer if (((filp->f_flags & O_NONBLOCK) || chan->poll_used) &&
1595a53d1202SEli Billauer !READ_ONCE(fifo->fill))
1596a53d1202SEli Billauer request_read_anything(chan, OPCODE_SET_PUSH);
1597a53d1202SEli Billauer
1598a53d1202SEli Billauer mutex_unlock(&chan->in_mutex);
1599a53d1202SEli Billauer
1600a53d1202SEli Billauer if (bytes_done)
1601a53d1202SEli Billauer return bytes_done;
1602a53d1202SEli Billauer
1603a53d1202SEli Billauer return rc;
1604a53d1202SEli Billauer }
1605a53d1202SEli Billauer
xillyusb_flush(struct file * filp,fl_owner_t id)1606a53d1202SEli Billauer static int xillyusb_flush(struct file *filp, fl_owner_t id)
1607a53d1202SEli Billauer {
1608a53d1202SEli Billauer struct xillyusb_channel *chan = filp->private_data;
1609a53d1202SEli Billauer int rc;
1610a53d1202SEli Billauer
1611a53d1202SEli Billauer if (!(filp->f_mode & FMODE_WRITE))
1612a53d1202SEli Billauer return 0;
1613a53d1202SEli Billauer
1614a53d1202SEli Billauer rc = mutex_lock_interruptible(&chan->out_mutex);
1615a53d1202SEli Billauer
1616a53d1202SEli Billauer if (rc)
1617a53d1202SEli Billauer return rc;
1618a53d1202SEli Billauer
1619a53d1202SEli Billauer /*
1620a53d1202SEli Billauer * One second's timeout on flushing. Interrupts are ignored, because if
1621a53d1202SEli Billauer * the user pressed CTRL-C, that interrupt will still be in flight by
1622a53d1202SEli Billauer * the time we reach here, and the opportunity to flush is lost.
1623a53d1202SEli Billauer */
1624a53d1202SEli Billauer rc = flush_downstream(chan, HZ, false);
1625a53d1202SEli Billauer
1626a53d1202SEli Billauer mutex_unlock(&chan->out_mutex);
1627a53d1202SEli Billauer
1628a53d1202SEli Billauer if (rc == -ETIMEDOUT) {
1629a53d1202SEli Billauer /* The things you do to use dev_warn() and not pr_warn() */
1630a53d1202SEli Billauer struct xillyusb_dev *xdev = chan->xdev;
1631a53d1202SEli Billauer
1632a53d1202SEli Billauer mutex_lock(&chan->lock);
1633a53d1202SEli Billauer if (!xdev->error)
1634a53d1202SEli Billauer dev_warn(xdev->dev,
1635a53d1202SEli Billauer "Timed out while flushing. Output data may be lost.\n");
1636a53d1202SEli Billauer mutex_unlock(&chan->lock);
1637a53d1202SEli Billauer }
1638a53d1202SEli Billauer
1639a53d1202SEli Billauer return rc;
1640a53d1202SEli Billauer }
1641a53d1202SEli Billauer
xillyusb_write(struct file * filp,const char __user * userbuf,size_t count,loff_t * f_pos)1642a53d1202SEli Billauer static ssize_t xillyusb_write(struct file *filp, const char __user *userbuf,
1643a53d1202SEli Billauer size_t count, loff_t *f_pos)
1644a53d1202SEli Billauer {
1645a53d1202SEli Billauer struct xillyusb_channel *chan = filp->private_data;
1646a53d1202SEli Billauer struct xillyusb_dev *xdev = chan->xdev;
1647a53d1202SEli Billauer struct xillyfifo *fifo = &chan->out_ep->fifo;
1648a53d1202SEli Billauer int rc;
1649a53d1202SEli Billauer
1650a53d1202SEli Billauer rc = mutex_lock_interruptible(&chan->out_mutex);
1651a53d1202SEli Billauer
1652a53d1202SEli Billauer if (rc)
1653a53d1202SEli Billauer return rc;
1654a53d1202SEli Billauer
1655a53d1202SEli Billauer while (1) {
1656a53d1202SEli Billauer if (xdev->error) {
1657a53d1202SEli Billauer rc = xdev->error;
1658a53d1202SEli Billauer break;
1659a53d1202SEli Billauer }
1660a53d1202SEli Billauer
1661a53d1202SEli Billauer if (count == 0)
1662a53d1202SEli Billauer break;
1663a53d1202SEli Billauer
1664a53d1202SEli Billauer rc = fifo_write(fifo, (__force void *)userbuf, count,
1665a53d1202SEli Billauer xilly_copy_from_user);
1666a53d1202SEli Billauer
1667a53d1202SEli Billauer if (rc != 0)
1668a53d1202SEli Billauer break;
1669a53d1202SEli Billauer
1670a53d1202SEli Billauer if (filp->f_flags & O_NONBLOCK) {
1671a53d1202SEli Billauer rc = -EAGAIN;
1672a53d1202SEli Billauer break;
1673a53d1202SEli Billauer }
1674a53d1202SEli Billauer
1675a53d1202SEli Billauer if (wait_event_interruptible
1676a53d1202SEli Billauer (fifo->waitq,
1677a53d1202SEli Billauer fifo->fill != fifo->size || xdev->error)) {
1678a53d1202SEli Billauer rc = -EINTR;
1679a53d1202SEli Billauer break;
1680a53d1202SEli Billauer }
1681a53d1202SEli Billauer }
1682a53d1202SEli Billauer
1683a53d1202SEli Billauer if (rc < 0)
1684a53d1202SEli Billauer goto done;
1685a53d1202SEli Billauer
1686a53d1202SEli Billauer chan->out_bytes += rc;
1687a53d1202SEli Billauer
1688a53d1202SEli Billauer if (rc) {
1689a53d1202SEli Billauer try_queue_bulk_out(chan->out_ep);
1690a53d1202SEli Billauer chan->flushed = 0;
1691a53d1202SEli Billauer }
1692a53d1202SEli Billauer
1693a53d1202SEli Billauer if (chan->out_synchronous) {
1694a53d1202SEli Billauer int flush_rc = flush_downstream(chan, 0, true);
1695a53d1202SEli Billauer
1696a53d1202SEli Billauer if (flush_rc && !rc)
1697a53d1202SEli Billauer rc = flush_rc;
1698a53d1202SEli Billauer }
1699a53d1202SEli Billauer
1700a53d1202SEli Billauer done:
1701a53d1202SEli Billauer mutex_unlock(&chan->out_mutex);
1702a53d1202SEli Billauer
1703a53d1202SEli Billauer return rc;
1704a53d1202SEli Billauer }
1705a53d1202SEli Billauer
xillyusb_release(struct inode * inode,struct file * filp)1706a53d1202SEli Billauer static int xillyusb_release(struct inode *inode, struct file *filp)
1707a53d1202SEli Billauer {
1708a53d1202SEli Billauer struct xillyusb_channel *chan = filp->private_data;
1709a53d1202SEli Billauer struct xillyusb_dev *xdev = chan->xdev;
1710a53d1202SEli Billauer int rc_read = 0, rc_write = 0;
1711a53d1202SEli Billauer
1712a53d1202SEli Billauer if (filp->f_mode & FMODE_READ) {
1713a53d1202SEli Billauer struct xillyfifo *in_fifo = chan->in_fifo;
1714a53d1202SEli Billauer
1715a53d1202SEli Billauer rc_read = xillyusb_send_opcode(xdev, (chan->chan_idx << 1) | 1,
1716a53d1202SEli Billauer OPCODE_CLOSE, 0);
1717a53d1202SEli Billauer /*
1718a53d1202SEli Billauer * If rc_read is nonzero, xdev->error indicates a global
1719a53d1202SEli Billauer * device error. The error is reported later, so that
1720a53d1202SEli Billauer * resources are freed.
1721a53d1202SEli Billauer *
1722a53d1202SEli Billauer * Looping on wait_event_interruptible() kinda breaks the idea
1723a53d1202SEli Billauer * of being interruptible, and this should have been
1724a53d1202SEli Billauer * wait_event(). Only it's being waken with
1725a53d1202SEli Billauer * wake_up_interruptible() for the sake of other uses. If
1726a53d1202SEli Billauer * there's a global device error, chan->read_data_ok is
1727a53d1202SEli Billauer * deasserted and the wait queue is awaken, so this is covered.
1728a53d1202SEli Billauer */
1729a53d1202SEli Billauer
1730a53d1202SEli Billauer while (wait_event_interruptible(in_fifo->waitq,
1731a53d1202SEli Billauer !chan->read_data_ok))
1732a53d1202SEli Billauer ; /* Empty loop */
1733a53d1202SEli Billauer
1734a53d1202SEli Billauer safely_assign_in_fifo(chan, NULL);
1735a53d1202SEli Billauer fifo_mem_release(in_fifo);
1736a53d1202SEli Billauer kfree(in_fifo);
1737a53d1202SEli Billauer
1738a53d1202SEli Billauer mutex_lock(&chan->lock);
1739a53d1202SEli Billauer chan->open_for_read = 0;
1740a53d1202SEli Billauer mutex_unlock(&chan->lock);
1741a53d1202SEli Billauer }
1742a53d1202SEli Billauer
1743a53d1202SEli Billauer if (filp->f_mode & FMODE_WRITE) {
1744a53d1202SEli Billauer struct xillyusb_endpoint *ep = chan->out_ep;
1745a53d1202SEli Billauer /*
1746a53d1202SEli Billauer * chan->flushing isn't zeroed. If the pre-release flush timed
1747a53d1202SEli Billauer * out, a cancel request will be sent before the next
1748a53d1202SEli Billauer * OPCODE_SET_CHECKPOINT (i.e. when the file is opened again).
1749a53d1202SEli Billauer * This is despite that the FPGA forgets about the checkpoint
1750a53d1202SEli Billauer * request as the file closes. Still, in an exceptional race
1751a53d1202SEli Billauer * condition, the FPGA could send an OPCODE_REACHED_CHECKPOINT
1752a53d1202SEli Billauer * just before closing that would reach the host after the
1753a53d1202SEli Billauer * file has re-opened.
1754a53d1202SEli Billauer */
1755a53d1202SEli Billauer
1756a53d1202SEli Billauer mutex_lock(&chan->lock);
1757a53d1202SEli Billauer chan->out_ep = NULL;
1758a53d1202SEli Billauer mutex_unlock(&chan->lock);
1759a53d1202SEli Billauer
1760a53d1202SEli Billauer endpoint_quiesce(ep);
1761a53d1202SEli Billauer endpoint_dealloc(ep);
1762a53d1202SEli Billauer
1763a53d1202SEli Billauer /* See comments on rc_read above */
1764a53d1202SEli Billauer rc_write = xillyusb_send_opcode(xdev, chan->chan_idx << 1,
1765a53d1202SEli Billauer OPCODE_CLOSE, 0);
1766a53d1202SEli Billauer
1767a53d1202SEli Billauer mutex_lock(&chan->lock);
1768a53d1202SEli Billauer chan->open_for_write = 0;
1769a53d1202SEli Billauer mutex_unlock(&chan->lock);
1770a53d1202SEli Billauer }
1771a53d1202SEli Billauer
1772a53d1202SEli Billauer kref_put(&xdev->kref, cleanup_dev);
1773a53d1202SEli Billauer
1774a53d1202SEli Billauer return rc_read ? rc_read : rc_write;
1775a53d1202SEli Billauer }
1776a53d1202SEli Billauer
1777a53d1202SEli Billauer /*
1778a53d1202SEli Billauer * Xillybus' API allows device nodes to be seekable, giving the user
1779a53d1202SEli Billauer * application access to a RAM array on the FPGA (or logic emulating it).
1780a53d1202SEli Billauer */
1781a53d1202SEli Billauer
xillyusb_llseek(struct file * filp,loff_t offset,int whence)1782a53d1202SEli Billauer static loff_t xillyusb_llseek(struct file *filp, loff_t offset, int whence)
1783a53d1202SEli Billauer {
1784a53d1202SEli Billauer struct xillyusb_channel *chan = filp->private_data;
1785a53d1202SEli Billauer struct xillyusb_dev *xdev = chan->xdev;
1786a53d1202SEli Billauer loff_t pos = filp->f_pos;
1787a53d1202SEli Billauer int rc = 0;
1788a53d1202SEli Billauer unsigned int log2_element_size = chan->readable ?
1789a53d1202SEli Billauer chan->in_log2_element_size : chan->out_log2_element_size;
1790a53d1202SEli Billauer
1791a53d1202SEli Billauer /*
1792a53d1202SEli Billauer * Take both mutexes not allowing interrupts, since it seems like
1793a53d1202SEli Billauer * common applications don't expect an -EINTR here. Besides, multiple
1794a53d1202SEli Billauer * access to a single file descriptor on seekable devices is a mess
1795a53d1202SEli Billauer * anyhow.
1796a53d1202SEli Billauer */
1797a53d1202SEli Billauer
1798a53d1202SEli Billauer mutex_lock(&chan->out_mutex);
1799a53d1202SEli Billauer mutex_lock(&chan->in_mutex);
1800a53d1202SEli Billauer
1801a53d1202SEli Billauer switch (whence) {
1802a53d1202SEli Billauer case SEEK_SET:
1803a53d1202SEli Billauer pos = offset;
1804a53d1202SEli Billauer break;
1805a53d1202SEli Billauer case SEEK_CUR:
1806a53d1202SEli Billauer pos += offset;
1807a53d1202SEli Billauer break;
1808a53d1202SEli Billauer case SEEK_END:
1809a53d1202SEli Billauer pos = offset; /* Going to the end => to the beginning */
1810a53d1202SEli Billauer break;
1811a53d1202SEli Billauer default:
1812a53d1202SEli Billauer rc = -EINVAL;
1813a53d1202SEli Billauer goto end;
1814a53d1202SEli Billauer }
1815a53d1202SEli Billauer
1816a53d1202SEli Billauer /* In any case, we must finish on an element boundary */
1817a53d1202SEli Billauer if (pos & ((1 << log2_element_size) - 1)) {
1818a53d1202SEli Billauer rc = -EINVAL;
1819a53d1202SEli Billauer goto end;
1820a53d1202SEli Billauer }
1821a53d1202SEli Billauer
1822a53d1202SEli Billauer rc = xillyusb_send_opcode(xdev, chan->chan_idx << 1,
1823a53d1202SEli Billauer OPCODE_SET_ADDR,
1824a53d1202SEli Billauer pos >> log2_element_size);
1825a53d1202SEli Billauer
1826a53d1202SEli Billauer if (rc)
1827a53d1202SEli Billauer goto end;
1828a53d1202SEli Billauer
1829a53d1202SEli Billauer if (chan->writable) {
1830a53d1202SEli Billauer chan->flushed = 0;
1831a53d1202SEli Billauer rc = flush_downstream(chan, HZ, false);
1832a53d1202SEli Billauer }
1833a53d1202SEli Billauer
1834a53d1202SEli Billauer end:
1835a53d1202SEli Billauer mutex_unlock(&chan->out_mutex);
1836a53d1202SEli Billauer mutex_unlock(&chan->in_mutex);
1837a53d1202SEli Billauer
1838a53d1202SEli Billauer if (rc) /* Return error after releasing mutexes */
1839a53d1202SEli Billauer return rc;
1840a53d1202SEli Billauer
1841a53d1202SEli Billauer filp->f_pos = pos;
1842a53d1202SEli Billauer
1843a53d1202SEli Billauer return pos;
1844a53d1202SEli Billauer }
1845a53d1202SEli Billauer
xillyusb_poll(struct file * filp,poll_table * wait)1846a53d1202SEli Billauer static __poll_t xillyusb_poll(struct file *filp, poll_table *wait)
1847a53d1202SEli Billauer {
1848a53d1202SEli Billauer struct xillyusb_channel *chan = filp->private_data;
1849a53d1202SEli Billauer __poll_t mask = 0;
1850a53d1202SEli Billauer
1851a53d1202SEli Billauer if (chan->in_fifo)
1852a53d1202SEli Billauer poll_wait(filp, &chan->in_fifo->waitq, wait);
1853a53d1202SEli Billauer
1854a53d1202SEli Billauer if (chan->out_ep)
1855a53d1202SEli Billauer poll_wait(filp, &chan->out_ep->fifo.waitq, wait);
1856a53d1202SEli Billauer
1857a53d1202SEli Billauer /*
1858a53d1202SEli Billauer * If this is the first time poll() is called, and the file is
1859a53d1202SEli Billauer * readable, set the relevant flag. Also tell the FPGA to send all it
1860a53d1202SEli Billauer * has, to kickstart the mechanism that ensures there's always some
1861a53d1202SEli Billauer * data in in_fifo unless the stream is dry end-to-end. Note that the
1862a53d1202SEli Billauer * first poll() may not return a EPOLLIN, even if there's data on the
1863a53d1202SEli Billauer * FPGA. Rather, the data will arrive soon, and trigger the relevant
1864a53d1202SEli Billauer * wait queue.
1865a53d1202SEli Billauer */
1866a53d1202SEli Billauer
1867a53d1202SEli Billauer if (!chan->poll_used && chan->in_fifo) {
1868a53d1202SEli Billauer chan->poll_used = 1;
1869a53d1202SEli Billauer request_read_anything(chan, OPCODE_SET_PUSH);
1870a53d1202SEli Billauer }
1871a53d1202SEli Billauer
1872a53d1202SEli Billauer /*
1873a53d1202SEli Billauer * poll() won't play ball regarding read() channels which
1874a53d1202SEli Billauer * are synchronous. Allowing that will create situations where data has
1875a53d1202SEli Billauer * been delivered at the FPGA, and users expecting select() to wake up,
1876a53d1202SEli Billauer * which it may not. So make it never work.
1877a53d1202SEli Billauer */
1878a53d1202SEli Billauer
1879a53d1202SEli Billauer if (chan->in_fifo && !chan->in_synchronous &&
1880a53d1202SEli Billauer (READ_ONCE(chan->in_fifo->fill) || !chan->read_data_ok))
1881a53d1202SEli Billauer mask |= EPOLLIN | EPOLLRDNORM;
1882a53d1202SEli Billauer
1883a53d1202SEli Billauer if (chan->out_ep &&
1884a53d1202SEli Billauer (READ_ONCE(chan->out_ep->fifo.fill) != chan->out_ep->fifo.size))
1885a53d1202SEli Billauer mask |= EPOLLOUT | EPOLLWRNORM;
1886a53d1202SEli Billauer
1887a53d1202SEli Billauer if (chan->xdev->error)
1888a53d1202SEli Billauer mask |= EPOLLERR;
1889a53d1202SEli Billauer
1890a53d1202SEli Billauer return mask;
1891a53d1202SEli Billauer }
1892a53d1202SEli Billauer
1893a53d1202SEli Billauer static const struct file_operations xillyusb_fops = {
1894a53d1202SEli Billauer .owner = THIS_MODULE,
1895a53d1202SEli Billauer .read = xillyusb_read,
1896a53d1202SEli Billauer .write = xillyusb_write,
1897a53d1202SEli Billauer .open = xillyusb_open,
1898a53d1202SEli Billauer .flush = xillyusb_flush,
1899a53d1202SEli Billauer .release = xillyusb_release,
1900a53d1202SEli Billauer .llseek = xillyusb_llseek,
1901a53d1202SEli Billauer .poll = xillyusb_poll,
1902a53d1202SEli Billauer };
1903a53d1202SEli Billauer
xillyusb_setup_base_eps(struct xillyusb_dev * xdev)1904a53d1202SEli Billauer static int xillyusb_setup_base_eps(struct xillyusb_dev *xdev)
1905a53d1202SEli Billauer {
1906*5cff7546SEli Billauer struct usb_device *udev = xdev->udev;
1907*5cff7546SEli Billauer
1908*5cff7546SEli Billauer /* Verify that device has the two fundamental bulk in/out endpoints */
1909*5cff7546SEli Billauer if (usb_pipe_type_check(udev, usb_sndbulkpipe(udev, MSG_EP_NUM)) ||
1910*5cff7546SEli Billauer usb_pipe_type_check(udev, usb_rcvbulkpipe(udev, IN_EP_NUM)))
1911*5cff7546SEli Billauer return -ENODEV;
1912*5cff7546SEli Billauer
1913a53d1202SEli Billauer xdev->msg_ep = endpoint_alloc(xdev, MSG_EP_NUM | USB_DIR_OUT,
1914a53d1202SEli Billauer bulk_out_work, 1, 2);
1915a53d1202SEli Billauer if (!xdev->msg_ep)
1916a53d1202SEli Billauer return -ENOMEM;
1917a53d1202SEli Billauer
1918a53d1202SEli Billauer if (fifo_init(&xdev->msg_ep->fifo, 13)) /* 8 kiB */
1919a53d1202SEli Billauer goto dealloc;
1920a53d1202SEli Billauer
1921a53d1202SEli Billauer xdev->msg_ep->fill_mask = -8; /* 8 bytes granularity */
1922a53d1202SEli Billauer
1923a53d1202SEli Billauer xdev->in_ep = endpoint_alloc(xdev, IN_EP_NUM | USB_DIR_IN,
1924a53d1202SEli Billauer bulk_in_work, BUF_SIZE_ORDER, BUFNUM);
1925a53d1202SEli Billauer if (!xdev->in_ep)
1926a53d1202SEli Billauer goto dealloc;
1927a53d1202SEli Billauer
1928a53d1202SEli Billauer try_queue_bulk_in(xdev->in_ep);
1929a53d1202SEli Billauer
1930a53d1202SEli Billauer return 0;
1931a53d1202SEli Billauer
1932a53d1202SEli Billauer dealloc:
1933a53d1202SEli Billauer endpoint_dealloc(xdev->msg_ep); /* Also frees FIFO mem if allocated */
193415c9a359SZiyang Xuan xdev->msg_ep = NULL;
1935a53d1202SEli Billauer return -ENOMEM;
1936a53d1202SEli Billauer }
1937a53d1202SEli Billauer
setup_channels(struct xillyusb_dev * xdev,__le16 * chandesc,int num_channels)1938a53d1202SEli Billauer static int setup_channels(struct xillyusb_dev *xdev,
1939a53d1202SEli Billauer __le16 *chandesc,
1940a53d1202SEli Billauer int num_channels)
1941a53d1202SEli Billauer {
1942*5cff7546SEli Billauer struct usb_device *udev = xdev->udev;
1943*5cff7546SEli Billauer struct xillyusb_channel *chan, *new_channels;
1944a53d1202SEli Billauer int i;
1945a53d1202SEli Billauer
1946a53d1202SEli Billauer chan = kcalloc(num_channels, sizeof(*chan), GFP_KERNEL);
1947a53d1202SEli Billauer if (!chan)
1948a53d1202SEli Billauer return -ENOMEM;
1949a53d1202SEli Billauer
1950*5cff7546SEli Billauer new_channels = chan;
1951a53d1202SEli Billauer
1952a53d1202SEli Billauer for (i = 0; i < num_channels; i++, chan++) {
1953a53d1202SEli Billauer unsigned int in_desc = le16_to_cpu(*chandesc++);
1954a53d1202SEli Billauer unsigned int out_desc = le16_to_cpu(*chandesc++);
1955a53d1202SEli Billauer
1956a53d1202SEli Billauer chan->xdev = xdev;
1957a53d1202SEli Billauer mutex_init(&chan->in_mutex);
1958a53d1202SEli Billauer mutex_init(&chan->out_mutex);
1959a53d1202SEli Billauer mutex_init(&chan->lock);
1960a53d1202SEli Billauer init_waitqueue_head(&chan->flushq);
1961a53d1202SEli Billauer
1962a53d1202SEli Billauer chan->chan_idx = i;
1963a53d1202SEli Billauer
1964a53d1202SEli Billauer if (in_desc & 0x80) { /* Entry is valid */
1965a53d1202SEli Billauer chan->readable = 1;
1966a53d1202SEli Billauer chan->in_synchronous = !!(in_desc & 0x40);
1967a53d1202SEli Billauer chan->in_seekable = !!(in_desc & 0x20);
1968a53d1202SEli Billauer chan->in_log2_element_size = in_desc & 0x0f;
1969a53d1202SEli Billauer chan->in_log2_fifo_size = ((in_desc >> 8) & 0x1f) + 16;
1970a53d1202SEli Billauer }
1971a53d1202SEli Billauer
1972a53d1202SEli Billauer /*
1973a53d1202SEli Billauer * A downstream channel should never exist above index 13,
1974a53d1202SEli Billauer * as it would request a nonexistent BULK endpoint > 15.
1975a53d1202SEli Billauer * In the peculiar case that it does, it's ignored silently.
1976a53d1202SEli Billauer */
1977a53d1202SEli Billauer
1978a53d1202SEli Billauer if ((out_desc & 0x80) && i < 14) { /* Entry is valid */
1979*5cff7546SEli Billauer if (usb_pipe_type_check(udev,
1980*5cff7546SEli Billauer usb_sndbulkpipe(udev, i + 2))) {
1981*5cff7546SEli Billauer dev_err(xdev->dev,
1982*5cff7546SEli Billauer "Missing BULK OUT endpoint %d\n",
1983*5cff7546SEli Billauer i + 2);
1984*5cff7546SEli Billauer kfree(new_channels);
1985*5cff7546SEli Billauer return -ENODEV;
1986*5cff7546SEli Billauer }
1987*5cff7546SEli Billauer
1988a53d1202SEli Billauer chan->writable = 1;
1989a53d1202SEli Billauer chan->out_synchronous = !!(out_desc & 0x40);
1990a53d1202SEli Billauer chan->out_seekable = !!(out_desc & 0x20);
1991a53d1202SEli Billauer chan->out_log2_element_size = out_desc & 0x0f;
1992a53d1202SEli Billauer chan->out_log2_fifo_size =
1993a53d1202SEli Billauer ((out_desc >> 8) & 0x1f) + 16;
1994a53d1202SEli Billauer }
1995a53d1202SEli Billauer }
1996a53d1202SEli Billauer
1997*5cff7546SEli Billauer xdev->channels = new_channels;
1998a53d1202SEli Billauer return 0;
1999a53d1202SEli Billauer }
2000a53d1202SEli Billauer
xillyusb_discovery(struct usb_interface * interface)2001a53d1202SEli Billauer static int xillyusb_discovery(struct usb_interface *interface)
2002a53d1202SEli Billauer {
2003a53d1202SEli Billauer int rc;
2004a53d1202SEli Billauer struct xillyusb_dev *xdev = usb_get_intfdata(interface);
2005a53d1202SEli Billauer __le16 bogus_chandesc[2];
2006a53d1202SEli Billauer struct xillyfifo idt_fifo;
2007a53d1202SEli Billauer struct xillyusb_channel *chan;
2008a53d1202SEli Billauer unsigned int idt_len, names_offset;
2009a53d1202SEli Billauer unsigned char *idt;
2010a53d1202SEli Billauer int num_channels;
2011a53d1202SEli Billauer
2012a53d1202SEli Billauer rc = xillyusb_send_opcode(xdev, ~0, OPCODE_QUIESCE, 0);
2013a53d1202SEli Billauer
2014a53d1202SEli Billauer if (rc) {
2015a53d1202SEli Billauer dev_err(&interface->dev, "Failed to send quiesce request. Aborting.\n");
2016a53d1202SEli Billauer return rc;
2017a53d1202SEli Billauer }
2018a53d1202SEli Billauer
2019a53d1202SEli Billauer /* Phase I: Set up one fake upstream channel and obtain IDT */
2020a53d1202SEli Billauer
2021a53d1202SEli Billauer /* Set up a fake IDT with one async IN stream */
2022a53d1202SEli Billauer bogus_chandesc[0] = cpu_to_le16(0x80);
2023a53d1202SEli Billauer bogus_chandesc[1] = cpu_to_le16(0);
2024a53d1202SEli Billauer
2025a53d1202SEli Billauer rc = setup_channels(xdev, bogus_chandesc, 1);
2026a53d1202SEli Billauer
2027a53d1202SEli Billauer if (rc)
2028a53d1202SEli Billauer return rc;
2029a53d1202SEli Billauer
2030a53d1202SEli Billauer rc = fifo_init(&idt_fifo, LOG2_IDT_FIFO_SIZE);
2031a53d1202SEli Billauer
2032a53d1202SEli Billauer if (rc)
2033a53d1202SEli Billauer return rc;
2034a53d1202SEli Billauer
2035a53d1202SEli Billauer chan = xdev->channels;
2036a53d1202SEli Billauer
2037a53d1202SEli Billauer chan->in_fifo = &idt_fifo;
2038a53d1202SEli Billauer chan->read_data_ok = 1;
2039a53d1202SEli Billauer
2040a53d1202SEli Billauer xdev->num_channels = 1;
2041a53d1202SEli Billauer
2042a53d1202SEli Billauer rc = xillyusb_send_opcode(xdev, ~0, OPCODE_REQ_IDT, 0);
2043a53d1202SEli Billauer
2044a53d1202SEli Billauer if (rc) {
2045a53d1202SEli Billauer dev_err(&interface->dev, "Failed to send IDT request. Aborting.\n");
2046a53d1202SEli Billauer goto unfifo;
2047a53d1202SEli Billauer }
2048a53d1202SEli Billauer
2049a53d1202SEli Billauer rc = wait_event_interruptible_timeout(idt_fifo.waitq,
2050a53d1202SEli Billauer !chan->read_data_ok,
2051a53d1202SEli Billauer XILLY_RESPONSE_TIMEOUT);
2052a53d1202SEli Billauer
2053a53d1202SEli Billauer if (xdev->error) {
2054a53d1202SEli Billauer rc = xdev->error;
2055a53d1202SEli Billauer goto unfifo;
2056a53d1202SEli Billauer }
2057a53d1202SEli Billauer
2058a53d1202SEli Billauer if (rc < 0) {
2059a53d1202SEli Billauer rc = -EINTR; /* Interrupt on probe method? Interesting. */
2060a53d1202SEli Billauer goto unfifo;
2061a53d1202SEli Billauer }
2062a53d1202SEli Billauer
2063a53d1202SEli Billauer if (chan->read_data_ok) {
2064a53d1202SEli Billauer rc = -ETIMEDOUT;
2065a53d1202SEli Billauer dev_err(&interface->dev, "No response from FPGA. Aborting.\n");
2066a53d1202SEli Billauer goto unfifo;
2067a53d1202SEli Billauer }
2068a53d1202SEli Billauer
2069a53d1202SEli Billauer idt_len = READ_ONCE(idt_fifo.fill);
2070a53d1202SEli Billauer idt = kmalloc(idt_len, GFP_KERNEL);
2071a53d1202SEli Billauer
2072a53d1202SEli Billauer if (!idt) {
2073a53d1202SEli Billauer rc = -ENOMEM;
2074a53d1202SEli Billauer goto unfifo;
2075a53d1202SEli Billauer }
2076a53d1202SEli Billauer
2077a53d1202SEli Billauer fifo_read(&idt_fifo, idt, idt_len, xilly_memcpy);
2078a53d1202SEli Billauer
2079a53d1202SEli Billauer if (crc32_le(~0, idt, idt_len) != 0) {
2080a53d1202SEli Billauer dev_err(&interface->dev, "IDT failed CRC check. Aborting.\n");
2081a53d1202SEli Billauer rc = -ENODEV;
2082a53d1202SEli Billauer goto unidt;
2083a53d1202SEli Billauer }
2084a53d1202SEli Billauer
2085a53d1202SEli Billauer if (*idt > 0x90) {
2086a53d1202SEli Billauer dev_err(&interface->dev, "No support for IDT version 0x%02x. Maybe the xillyusb driver needs an upgrade. Aborting.\n",
2087a53d1202SEli Billauer (int)*idt);
2088a53d1202SEli Billauer rc = -ENODEV;
2089a53d1202SEli Billauer goto unidt;
2090a53d1202SEli Billauer }
2091a53d1202SEli Billauer
2092a53d1202SEli Billauer /* Phase II: Set up the streams as defined in IDT */
2093a53d1202SEli Billauer
2094a53d1202SEli Billauer num_channels = le16_to_cpu(*((__le16 *)(idt + 1)));
2095a53d1202SEli Billauer names_offset = 3 + num_channels * 4;
2096a53d1202SEli Billauer idt_len -= 4; /* Exclude CRC */
2097a53d1202SEli Billauer
2098a53d1202SEli Billauer if (idt_len < names_offset) {
2099a53d1202SEli Billauer dev_err(&interface->dev, "IDT too short. This is exceptionally weird, because its CRC is OK\n");
2100a53d1202SEli Billauer rc = -ENODEV;
2101a53d1202SEli Billauer goto unidt;
2102a53d1202SEli Billauer }
2103a53d1202SEli Billauer
2104a53d1202SEli Billauer rc = setup_channels(xdev, (void *)idt + 3, num_channels);
2105a53d1202SEli Billauer
2106a53d1202SEli Billauer if (rc)
2107a53d1202SEli Billauer goto unidt;
2108a53d1202SEli Billauer
2109a53d1202SEli Billauer /*
2110a53d1202SEli Billauer * Except for wildly misbehaving hardware, or if it was disconnected
2111a53d1202SEli Billauer * just after responding with the IDT, there is no reason for any
2112a53d1202SEli Billauer * work item to be running now. To be sure that xdev->channels
2113a53d1202SEli Billauer * is updated on anything that might run in parallel, flush the
2114435fc9caSEli Billauer * device's workqueue and the wakeup work item. This rarely
2115435fc9caSEli Billauer * does anything.
2116a53d1202SEli Billauer */
2117a53d1202SEli Billauer flush_workqueue(xdev->workq);
2118435fc9caSEli Billauer flush_work(&xdev->wakeup_workitem);
2119a53d1202SEli Billauer
2120a53d1202SEli Billauer xdev->num_channels = num_channels;
2121a53d1202SEli Billauer
2122a53d1202SEli Billauer fifo_mem_release(&idt_fifo);
2123a53d1202SEli Billauer kfree(chan);
2124a53d1202SEli Billauer
2125a53d1202SEli Billauer rc = xillybus_init_chrdev(&interface->dev, &xillyusb_fops,
2126a53d1202SEli Billauer THIS_MODULE, xdev,
2127a53d1202SEli Billauer idt + names_offset,
2128a53d1202SEli Billauer idt_len - names_offset,
2129a53d1202SEli Billauer num_channels,
2130a53d1202SEli Billauer xillyname, true);
2131a53d1202SEli Billauer
2132a53d1202SEli Billauer kfree(idt);
2133a53d1202SEli Billauer
2134a53d1202SEli Billauer return rc;
2135a53d1202SEli Billauer
2136a53d1202SEli Billauer unidt:
2137a53d1202SEli Billauer kfree(idt);
2138a53d1202SEli Billauer
2139a53d1202SEli Billauer unfifo:
2140a53d1202SEli Billauer safely_assign_in_fifo(chan, NULL);
2141a53d1202SEli Billauer fifo_mem_release(&idt_fifo);
2142a53d1202SEli Billauer
2143a53d1202SEli Billauer return rc;
2144a53d1202SEli Billauer }
2145a53d1202SEli Billauer
xillyusb_probe(struct usb_interface * interface,const struct usb_device_id * id)2146a53d1202SEli Billauer static int xillyusb_probe(struct usb_interface *interface,
2147a53d1202SEli Billauer const struct usb_device_id *id)
2148a53d1202SEli Billauer {
2149a53d1202SEli Billauer struct xillyusb_dev *xdev;
2150a53d1202SEli Billauer int rc;
2151a53d1202SEli Billauer
2152a53d1202SEli Billauer xdev = kzalloc(sizeof(*xdev), GFP_KERNEL);
2153a53d1202SEli Billauer if (!xdev)
2154a53d1202SEli Billauer return -ENOMEM;
2155a53d1202SEli Billauer
2156a53d1202SEli Billauer kref_init(&xdev->kref);
2157a53d1202SEli Billauer mutex_init(&xdev->process_in_mutex);
2158a53d1202SEli Billauer mutex_init(&xdev->msg_mutex);
2159a53d1202SEli Billauer
2160a53d1202SEli Billauer xdev->udev = usb_get_dev(interface_to_usbdev(interface));
2161a53d1202SEli Billauer xdev->dev = &interface->dev;
2162a53d1202SEli Billauer xdev->error = 0;
2163a53d1202SEli Billauer spin_lock_init(&xdev->error_lock);
2164a53d1202SEli Billauer xdev->in_counter = 0;
2165a53d1202SEli Billauer xdev->in_bytes_left = 0;
2166a53d1202SEli Billauer xdev->workq = alloc_workqueue(xillyname, WQ_HIGHPRI, 0);
2167a53d1202SEli Billauer
2168a53d1202SEli Billauer if (!xdev->workq) {
2169a53d1202SEli Billauer dev_err(&interface->dev, "Failed to allocate work queue\n");
2170a53d1202SEli Billauer rc = -ENOMEM;
2171a53d1202SEli Billauer goto fail;
2172a53d1202SEli Billauer }
2173a53d1202SEli Billauer
2174a53d1202SEli Billauer INIT_WORK(&xdev->wakeup_workitem, wakeup_all);
2175a53d1202SEli Billauer
2176a53d1202SEli Billauer usb_set_intfdata(interface, xdev);
2177a53d1202SEli Billauer
2178a53d1202SEli Billauer rc = xillyusb_setup_base_eps(xdev);
2179a53d1202SEli Billauer if (rc)
2180a53d1202SEli Billauer goto fail;
2181a53d1202SEli Billauer
2182a53d1202SEli Billauer rc = xillyusb_discovery(interface);
2183a53d1202SEli Billauer if (rc)
2184a53d1202SEli Billauer goto latefail;
2185a53d1202SEli Billauer
2186a53d1202SEli Billauer return 0;
2187a53d1202SEli Billauer
2188a53d1202SEli Billauer latefail:
2189a53d1202SEli Billauer endpoint_quiesce(xdev->in_ep);
2190a53d1202SEli Billauer endpoint_quiesce(xdev->msg_ep);
2191a53d1202SEli Billauer
2192a53d1202SEli Billauer fail:
2193a53d1202SEli Billauer usb_set_intfdata(interface, NULL);
2194a53d1202SEli Billauer kref_put(&xdev->kref, cleanup_dev);
2195a53d1202SEli Billauer return rc;
2196a53d1202SEli Billauer }
2197a53d1202SEli Billauer
xillyusb_disconnect(struct usb_interface * interface)2198a53d1202SEli Billauer static void xillyusb_disconnect(struct usb_interface *interface)
2199a53d1202SEli Billauer {
2200a53d1202SEli Billauer struct xillyusb_dev *xdev = usb_get_intfdata(interface);
2201a53d1202SEli Billauer struct xillyusb_endpoint *msg_ep = xdev->msg_ep;
2202a53d1202SEli Billauer struct xillyfifo *fifo = &msg_ep->fifo;
2203a53d1202SEli Billauer int rc;
2204a53d1202SEli Billauer int i;
2205a53d1202SEli Billauer
2206a53d1202SEli Billauer xillybus_cleanup_chrdev(xdev, &interface->dev);
2207a53d1202SEli Billauer
2208a53d1202SEli Billauer /*
2209a53d1202SEli Billauer * Try to send OPCODE_QUIESCE, which will fail silently if the device
2210a53d1202SEli Billauer * was disconnected, but makes sense on module unload.
2211a53d1202SEli Billauer */
2212a53d1202SEli Billauer
2213a53d1202SEli Billauer msg_ep->wake_on_drain = true;
2214a53d1202SEli Billauer xillyusb_send_opcode(xdev, ~0, OPCODE_QUIESCE, 0);
2215a53d1202SEli Billauer
2216a53d1202SEli Billauer /*
2217a53d1202SEli Billauer * If the device has been disconnected, sending the opcode causes
2218a53d1202SEli Billauer * a global device error with xdev->error, if such error didn't
2219a53d1202SEli Billauer * occur earlier. Hence timing out means that the USB link is fine,
2220a53d1202SEli Billauer * but somehow the message wasn't sent. Should never happen.
2221a53d1202SEli Billauer */
2222a53d1202SEli Billauer
2223a53d1202SEli Billauer rc = wait_event_interruptible_timeout(fifo->waitq,
2224a53d1202SEli Billauer msg_ep->drained || xdev->error,
2225a53d1202SEli Billauer XILLY_RESPONSE_TIMEOUT);
2226a53d1202SEli Billauer
2227a53d1202SEli Billauer if (!rc)
2228a53d1202SEli Billauer dev_err(&interface->dev,
2229a53d1202SEli Billauer "Weird timeout condition on sending quiesce request.\n");
2230a53d1202SEli Billauer
2231a53d1202SEli Billauer report_io_error(xdev, -ENODEV); /* Discourage further activity */
2232a53d1202SEli Billauer
2233a53d1202SEli Billauer /*
2234a53d1202SEli Billauer * This device driver is declared with soft_unbind set, or else
2235a53d1202SEli Billauer * sending OPCODE_QUIESCE above would always fail. The price is
2236a53d1202SEli Billauer * that the USB framework didn't kill outstanding URBs, so it has
2237a53d1202SEli Billauer * to be done explicitly before returning from this call.
2238a53d1202SEli Billauer */
2239a53d1202SEli Billauer
2240a53d1202SEli Billauer for (i = 0; i < xdev->num_channels; i++) {
2241a53d1202SEli Billauer struct xillyusb_channel *chan = &xdev->channels[i];
2242a53d1202SEli Billauer
2243a53d1202SEli Billauer /*
2244a53d1202SEli Billauer * Lock taken to prevent chan->out_ep from changing. It also
2245a53d1202SEli Billauer * ensures xillyusb_open() and xillyusb_flush() don't access
2246a53d1202SEli Billauer * xdev->dev after being nullified below.
2247a53d1202SEli Billauer */
2248a53d1202SEli Billauer mutex_lock(&chan->lock);
2249a53d1202SEli Billauer if (chan->out_ep)
2250a53d1202SEli Billauer endpoint_quiesce(chan->out_ep);
2251a53d1202SEli Billauer mutex_unlock(&chan->lock);
2252a53d1202SEli Billauer }
2253a53d1202SEli Billauer
2254a53d1202SEli Billauer endpoint_quiesce(xdev->in_ep);
2255a53d1202SEli Billauer endpoint_quiesce(xdev->msg_ep);
2256a53d1202SEli Billauer
2257a53d1202SEli Billauer usb_set_intfdata(interface, NULL);
2258a53d1202SEli Billauer
2259a53d1202SEli Billauer xdev->dev = NULL;
2260a53d1202SEli Billauer
2261282a4b71SEli Billauer mutex_lock(&kref_mutex);
2262a53d1202SEli Billauer kref_put(&xdev->kref, cleanup_dev);
2263282a4b71SEli Billauer mutex_unlock(&kref_mutex);
2264a53d1202SEli Billauer }
2265a53d1202SEli Billauer
2266a53d1202SEli Billauer static struct usb_driver xillyusb_driver = {
2267a53d1202SEli Billauer .name = xillyname,
2268a53d1202SEli Billauer .id_table = xillyusb_table,
2269a53d1202SEli Billauer .probe = xillyusb_probe,
2270a53d1202SEli Billauer .disconnect = xillyusb_disconnect,
2271a53d1202SEli Billauer .soft_unbind = 1,
2272a53d1202SEli Billauer };
2273a53d1202SEli Billauer
xillyusb_init(void)2274a53d1202SEli Billauer static int __init xillyusb_init(void)
2275a53d1202SEli Billauer {
2276a53d1202SEli Billauer int rc = 0;
2277a53d1202SEli Billauer
2278a7ad105bSEli Billauer wakeup_wq = alloc_workqueue(xillyname, 0, 0);
2279a7ad105bSEli Billauer if (!wakeup_wq)
2280a7ad105bSEli Billauer return -ENOMEM;
2281a7ad105bSEli Billauer
2282a53d1202SEli Billauer if (LOG2_INITIAL_FIFO_BUF_SIZE > PAGE_SHIFT)
2283a53d1202SEli Billauer fifo_buf_order = LOG2_INITIAL_FIFO_BUF_SIZE - PAGE_SHIFT;
2284a53d1202SEli Billauer else
2285a53d1202SEli Billauer fifo_buf_order = 0;
2286a53d1202SEli Billauer
2287a53d1202SEli Billauer rc = usb_register(&xillyusb_driver);
2288a53d1202SEli Billauer
2289a7ad105bSEli Billauer if (rc)
2290a7ad105bSEli Billauer destroy_workqueue(wakeup_wq);
2291a7ad105bSEli Billauer
2292a53d1202SEli Billauer return rc;
2293a53d1202SEli Billauer }
2294a53d1202SEli Billauer
xillyusb_exit(void)2295a53d1202SEli Billauer static void __exit xillyusb_exit(void)
2296a53d1202SEli Billauer {
2297a53d1202SEli Billauer usb_deregister(&xillyusb_driver);
2298435fc9caSEli Billauer
2299435fc9caSEli Billauer destroy_workqueue(wakeup_wq);
2300a53d1202SEli Billauer }
2301a53d1202SEli Billauer
2302a53d1202SEli Billauer module_init(xillyusb_init);
2303a53d1202SEli Billauer module_exit(xillyusb_exit);
2304