1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2017-2026 Morse Micro
4 */
5 #include <linux/jiffies.h>
6 #include <linux/module.h>
7 #include <linux/usb.h>
8 #include "hif.h"
9 #include "bus.h"
10 #include "mac.h"
11 #include "core.h"
12
13 /*
14 * URB timeout in milliseconds. If an URB does not complete within this
15 * time, it will be killed. This timeout needs to account for USB suspendand
16 * resume occurring before the URB can be transferred, and it also needs to
17 * account for transferring USB_MAX_TRANSFER_SIZE bytes over a potentially
18 * slow, congested USB Full Speed link.
19 */
20 #define URB_TIMEOUT_MS 250
21
22 /* High speed USB 2^(4-1) * 125usec = 1msec */
23 #define MM81X_USB_INTERRUPT_INTERVAL 4
24
25 /* Max bytes per USB read/write */
26 #define USB_MAX_TRANSFER_SIZE (16 * 1024)
27
28 /* INT EP buffer size */
29 #define MM81X_EP_INT_BUFFER_SIZE 8
30
31 /* Morse vendor IDs*/
32 #define MM81X_VENDOR_ID 0x325b
33 #define MM81X_MM810X_PRODUCT_ID 0x8100
34
35 /* Power management runtime auto-suspend delay value in milliseconds */
36 #define PM_RUNTIME_AUTOSUSPEND_DELAY_MS 100
37
38 enum mm81x_usb_endpoints {
39 MM81X_EP_CMD = 0,
40 MM81X_EP_INT,
41 MM81X_EP_MEM_RD,
42 MM81X_EP_MEM_WR,
43 MM81X_EP_REG_RD,
44 MM81X_EP_REG_WR,
45 MM81X_EP_EP_MAX,
46 };
47
48 struct mm81x_usb_endpoint {
49 unsigned char *buffer;
50 struct urb *urb;
51 __u8 addr;
52 int size;
53 };
54
55 enum mm81x_usb_flags { MM81X_USB_FLAG_ATTACHED, MM81X_USB_FLAG_SUSPENDED };
56
57 struct mm81x_usb {
58 struct usb_device *udev;
59 struct usb_interface *interface;
60 struct mm81x_usb_endpoint endpoints[MM81X_EP_EP_MAX];
61 int errors;
62
63 /* serialise USB device struct */
64 struct mutex lock;
65
66 /* serialise USB bus access */
67 struct mutex bus_lock;
68
69 bool ongoing_cmd;
70 bool ongoing_rw;
71 wait_queue_head_t rw_in_wait;
72 unsigned long flags;
73 };
74
75 enum mm81x_usb_command_direction {
76 MM81X_USB_WRITE = 0x00,
77 MM81X_USB_READ = 0x80,
78 MM81X_USB_RESET = 0x02,
79 };
80
81 struct mm81x_usb_command {
82 __le32 dir; /* Next BULK direction */
83 __le32 address; /* Next BULK address */
84 __le32 length; /* Next BULK size */
85 };
86
87 static const struct usb_device_id mm81x_usb_table[] = {
88 { USB_DEVICE(MM81X_VENDOR_ID, MM81X_MM810X_PRODUCT_ID) },
89 {} /* Terminating entry */
90 };
91
92 MODULE_DEVICE_TABLE(usb, mm81x_usb_table);
93
mm81x_usb_irq_work(struct work_struct * work)94 static void mm81x_usb_irq_work(struct work_struct *work)
95 {
96 struct mm81x *mors = container_of(work, struct mm81x, usb_irq_work);
97
98 mm81x_claim_bus(mors);
99 mm81x_hw_irq_handle(mors);
100 mm81x_release_bus(mors);
101 }
102
mm81x_usb_urb_status_is_disconnect(const struct urb * urb)103 static bool mm81x_usb_urb_status_is_disconnect(const struct urb *urb)
104 {
105 return ((urb->status == -EPROTO) || (urb->status == -EILSEQ) ||
106 (urb->status == -ETIME) || (urb->status == -EPIPE));
107 }
108
mm81x_usb_int_handler(struct urb * urb)109 static void mm81x_usb_int_handler(struct urb *urb)
110 {
111 int ret;
112 struct mm81x *mors = urb->context;
113 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
114
115 if (!test_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags))
116 return;
117
118 if (urb->status) {
119 if (mm81x_usb_urb_status_is_disconnect(urb)) {
120 clear_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags);
121 set_bit(MM81X_STATE_CHIP_UNRESPONSIVE,
122 &mors->state_flags);
123 dev_dbg(mors->dev,
124 "USB sudden disconnect detected in %s",
125 __func__);
126 return;
127 }
128
129 if (!(urb->status == -ENOENT || urb->status == -ECONNRESET ||
130 urb->status == -ESHUTDOWN))
131 dev_err(mors->dev, "- nonzero read status received: %d",
132 urb->status);
133 }
134
135 ret = usb_submit_urb(urb, GFP_ATOMIC);
136
137 /* usb_kill_urb has been called */
138 if (ret == -EPERM)
139 return;
140 else if (ret)
141 dev_err(mors->dev, "error: resubmit urb %p err code %d", urb,
142 ret);
143
144 queue_work(mors->chip_wq, &mors->usb_irq_work);
145 }
146
mm81x_usb_int_enable(struct mm81x * mors)147 static int mm81x_usb_int_enable(struct mm81x *mors)
148 {
149 int ret = 0;
150 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
151 struct urb *urb;
152
153 if (!test_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags))
154 return -ENODEV;
155
156 urb = usb_alloc_urb(0, GFP_KERNEL);
157 if (!urb) {
158 ret = -ENOMEM;
159 goto out;
160 }
161
162 musb->endpoints[MM81X_EP_INT].urb = urb;
163
164 musb->endpoints[MM81X_EP_INT].buffer =
165 usb_alloc_coherent(musb->udev, MM81X_EP_INT_BUFFER_SIZE,
166 GFP_KERNEL, &urb->transfer_dma);
167 if (!musb->endpoints[MM81X_EP_INT].buffer) {
168 dev_err(mors->dev, "couldn't allocate transfer_buffer");
169 ret = -ENOMEM;
170 goto error_set_urb_null;
171 }
172
173 usb_fill_int_urb(
174 musb->endpoints[MM81X_EP_INT].urb, musb->udev,
175 usb_rcvintpipe(musb->udev, musb->endpoints[MM81X_EP_INT].addr),
176 musb->endpoints[MM81X_EP_INT].buffer, MM81X_EP_INT_BUFFER_SIZE,
177 mm81x_usb_int_handler, mors, MM81X_USB_INTERRUPT_INTERVAL);
178 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
179
180 ret = usb_submit_urb(urb, GFP_KERNEL);
181 if (ret) {
182 dev_err(mors->dev, "Couldn't submit urb. Error number %d", ret);
183 goto error;
184 }
185
186 return 0;
187
188 error:
189 usb_free_coherent(musb->udev, MM81X_EP_INT_BUFFER_SIZE,
190 musb->endpoints[MM81X_EP_INT].buffer,
191 urb->transfer_dma);
192 error_set_urb_null:
193 musb->endpoints[MM81X_EP_INT].urb = NULL;
194 usb_free_urb(urb);
195 out:
196 return ret;
197 }
198
mm81x_usb_int_stop(struct mm81x * mors)199 static void mm81x_usb_int_stop(struct mm81x *mors)
200 {
201 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
202
203 usb_kill_urb(musb->endpoints[MM81X_EP_INT].urb);
204 cancel_work_sync(&mors->usb_irq_work);
205 }
206
mm81x_usb_cmd_callback(struct urb * urb)207 static void mm81x_usb_cmd_callback(struct urb *urb)
208 {
209 struct mm81x *mors = urb->context;
210 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
211
212 /* sync/async unlink faults aren't errors */
213 if (urb->status) {
214 if (!(urb->status == -ENOENT || urb->status == -ECONNRESET ||
215 urb->status == -ESHUTDOWN))
216 dev_err(mors->dev,
217 "nonzero write bulk status received: %d",
218 urb->status);
219
220 musb->errors = urb->status;
221 }
222
223 musb->ongoing_cmd = false;
224 wake_up(&musb->rw_in_wait);
225 }
226
mm81x_usb_cmd(struct mm81x_usb * musb,const struct mm81x_usb_command * cmd)227 static int mm81x_usb_cmd(struct mm81x_usb *musb,
228 const struct mm81x_usb_command *cmd)
229 {
230 int retval = 0;
231 struct mm81x *mors = usb_get_intfdata(musb->interface);
232 struct mm81x_usb_endpoint *ep = &musb->endpoints[MM81X_EP_CMD];
233 size_t writesize = sizeof(*cmd);
234
235 if (!test_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags))
236 return -ENODEV;
237
238 memcpy(ep->buffer, cmd, writesize);
239
240 usb_fill_bulk_urb(ep->urb, musb->udev,
241 usb_sndbulkpipe(musb->udev, ep->addr), ep->buffer,
242 writesize, mm81x_usb_cmd_callback, mors);
243 ep->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
244
245 musb->ongoing_cmd = true;
246
247 retval = usb_submit_urb(ep->urb, GFP_KERNEL);
248 if (retval) {
249 dev_err(mors->dev, "- failed submitting write urb, error %d",
250 retval);
251
252 goto error;
253 }
254
255 retval = wait_event_interruptible_timeout(
256 musb->rw_in_wait, (!musb->ongoing_cmd),
257 msecs_to_jiffies(URB_TIMEOUT_MS));
258 if (retval < 0) {
259 dev_err(mors->dev, "error waiting for urb %d", retval);
260 goto error;
261 } else if (retval == 0) {
262 dev_err(mors->dev, "timed out waiting for urb");
263 usb_kill_urb(ep->urb);
264 retval = -ETIMEDOUT;
265 goto error;
266 }
267
268 musb->ongoing_cmd = false;
269 return writesize;
270
271 error:
272 musb->ongoing_cmd = false;
273 return retval;
274 }
275
mm81x_usb_ndr_reset(struct mm81x * mors)276 static int mm81x_usb_ndr_reset(struct mm81x *mors)
277 {
278 int ret;
279 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
280 struct mm81x_usb_command cmd;
281
282 mutex_lock(&musb->lock);
283
284 musb->ongoing_rw = true;
285 musb->errors = 0;
286
287 cmd.dir = cpu_to_le32(MM81X_USB_RESET);
288 cmd.address = cpu_to_le32(0);
289 cmd.length = cpu_to_le32(0);
290
291 ret = mm81x_usb_cmd(musb, &cmd);
292 if (ret < 0)
293 dev_err(mors->dev, "mm81x_usb_cmd (MM81X_USB_RESET) error %d\n",
294 ret);
295 else
296 ret = 0;
297
298 musb->ongoing_rw = false;
299 mutex_unlock(&musb->lock);
300 return ret;
301 }
302
mm81x_usb_mem_rw_callback(struct urb * urb)303 static void mm81x_usb_mem_rw_callback(struct urb *urb)
304 {
305 struct mm81x *mors = urb->context;
306 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
307
308 /* sync/async unlink faults aren't errors */
309 if (urb->status) {
310 if (!(urb->status == -ENOENT || urb->status == -ECONNRESET ||
311 urb->status == -ESHUTDOWN))
312 dev_err(mors->dev,
313 "nonzero write bulk status received: %d",
314 urb->status);
315
316 musb->errors = urb->status;
317 }
318
319 musb->ongoing_rw = false;
320 wake_up(&musb->rw_in_wait);
321 }
322
mm81x_usb_mem_read(struct mm81x_usb * musb,u32 address,u8 * data,ssize_t size)323 static int mm81x_usb_mem_read(struct mm81x_usb *musb, u32 address, u8 *data,
324 ssize_t size)
325 {
326 int ret;
327 struct mm81x_usb_command cmd;
328 struct mm81x *mors = usb_get_intfdata(musb->interface);
329
330 if (!test_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags))
331 return -ENODEV;
332
333 mutex_lock(&musb->lock);
334
335 musb->ongoing_rw = true;
336 musb->errors = 0;
337
338 /* Send command ahead to prepare for Tokens */
339 cmd.dir = cpu_to_le32(MM81X_USB_READ);
340 cmd.address = cpu_to_le32(address);
341 cmd.length = cpu_to_le32(size);
342
343 ret = mm81x_usb_cmd(musb, &cmd);
344 if (ret < 0) {
345 dev_err(mors->dev, "mm81x_usb_cmd error %d", ret);
346 goto error;
347 }
348
349 /* Let's be fast push the next URB, don't wait until command is done */
350 usb_fill_bulk_urb(
351 musb->endpoints[MM81X_EP_MEM_RD].urb, musb->udev,
352 usb_rcvbulkpipe(musb->udev,
353 musb->endpoints[MM81X_EP_MEM_RD].addr),
354 musb->endpoints[MM81X_EP_MEM_RD].buffer, size,
355 mm81x_usb_mem_rw_callback, mors);
356
357 ret = usb_submit_urb(musb->endpoints[MM81X_EP_MEM_RD].urb, GFP_ATOMIC);
358 if (ret < 0) {
359 dev_err(mors->dev, "failed submitting read urb, error %d", ret);
360 ret = (ret == -ENOMEM) ? ret : -EIO;
361 goto error;
362 }
363
364 ret = wait_event_interruptible_timeout(
365 musb->rw_in_wait, (!musb->ongoing_rw),
366 msecs_to_jiffies(URB_TIMEOUT_MS));
367 if (ret < 0) {
368 dev_err(mors->dev, "wait_event_interruptible: error %d", ret);
369 goto error;
370 } else if (ret == 0) {
371 /* Timed out. */
372 usb_kill_urb(musb->endpoints[MM81X_EP_MEM_RD].urb);
373 }
374
375 if (musb->errors) {
376 ret = musb->errors;
377 dev_err(mors->dev, "mem read error %d", ret);
378 goto error;
379 }
380
381 memcpy(data, musb->endpoints[MM81X_EP_MEM_RD].buffer, size);
382 ret = size;
383
384 error:
385 musb->ongoing_rw = false;
386 mutex_unlock(&musb->lock);
387
388 return ret;
389 }
390
mm81x_usb_mem_write(struct mm81x_usb * musb,u32 address,u8 * data,ssize_t size)391 static int mm81x_usb_mem_write(struct mm81x_usb *musb, u32 address, u8 *data,
392 ssize_t size)
393 {
394 int ret;
395 struct mm81x_usb_command cmd;
396 struct mm81x *mors = usb_get_intfdata(musb->interface);
397
398 if (!test_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags))
399 return -ENODEV;
400
401 mutex_lock(&musb->lock);
402
403 musb->ongoing_rw = true;
404 musb->errors = 0;
405
406 /* Send command ahead to prepare for Tokens */
407 cmd.dir = cpu_to_le32(MM81X_USB_WRITE);
408 cmd.address = cpu_to_le32(address);
409 cmd.length = cpu_to_le32(size);
410 ret = mm81x_usb_cmd(musb, &cmd);
411 if (ret < 0) {
412 dev_err(mors->dev, "mm81x_usb_mem_read error %d", ret);
413 goto error;
414 }
415
416 memcpy(musb->endpoints[MM81X_EP_MEM_WR].buffer, data, size);
417
418 /* prepare a read */
419 usb_fill_bulk_urb(
420 musb->endpoints[MM81X_EP_MEM_WR].urb, musb->udev,
421 usb_sndbulkpipe(musb->udev,
422 musb->endpoints[MM81X_EP_MEM_WR].addr),
423 musb->endpoints[MM81X_EP_MEM_WR].buffer, size,
424 mm81x_usb_mem_rw_callback, mors);
425
426 ret = usb_submit_urb(musb->endpoints[MM81X_EP_MEM_WR].urb, GFP_ATOMIC);
427 if (ret < 0) {
428 dev_err(mors->dev, "- failed submitting write urb, error %d",
429 ret);
430 ret = (ret == -ENOMEM) ? ret : -EIO;
431 goto error;
432 }
433
434 ret = wait_event_interruptible_timeout(
435 musb->rw_in_wait, (!musb->ongoing_rw),
436 msecs_to_jiffies(URB_TIMEOUT_MS));
437 if (ret < 0) {
438 dev_err(mors->dev, "error %d", ret);
439 goto error;
440 } else if (ret == 0) {
441 /* Timed out. */
442 usb_kill_urb(musb->endpoints[MM81X_EP_MEM_WR].urb);
443 }
444
445 if (musb->errors) {
446 ret = musb->errors;
447 dev_err(mors->dev, "error %d", ret);
448 goto error;
449 }
450
451 ret = size;
452
453 error:
454 musb->ongoing_rw = false;
455 mutex_unlock(&musb->lock);
456 return ret;
457 }
458
mm81x_usb_dm_read(struct mm81x * mors,u32 address,u8 * data,int len)459 static int mm81x_usb_dm_read(struct mm81x *mors, u32 address, u8 *data, int len)
460 {
461 ssize_t offset = 0;
462 int ret;
463 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
464
465 while (offset < len) {
466 ret = mm81x_usb_mem_read(musb, address + offset,
467 (u8 *)(data + offset),
468 min((ssize_t)(len - offset),
469 (ssize_t)USB_MAX_TRANSFER_SIZE));
470 if (ret < 0) {
471 dev_err(mors->dev, "%s failed (errno=%d)", __func__,
472 ret);
473 return ret;
474 }
475
476 offset += ret;
477 }
478
479 return 0;
480 }
481
mm81x_usb_dm_write(struct mm81x * mors,u32 address,const u8 * data,int len)482 static int mm81x_usb_dm_write(struct mm81x *mors, u32 address, const u8 *data,
483 int len)
484 {
485 ssize_t offset = 0;
486 int ret;
487 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
488
489 while (offset < len) {
490 ret = mm81x_usb_mem_write(musb, address + offset,
491 (u8 *)(data + offset),
492 min((ssize_t)(len - offset),
493 (ssize_t)USB_MAX_TRANSFER_SIZE));
494 if (ret < 0) {
495 dev_err(mors->dev, "%s failed (errno=%d)", __func__,
496 ret);
497 return ret;
498 }
499
500 offset += ret;
501 }
502
503 return 0;
504 }
505
mm81x_usb_reg32_read(struct mm81x * mors,u32 address,u32 * val)506 static int mm81x_usb_reg32_read(struct mm81x *mors, u32 address, u32 *val)
507 {
508 int ret = 0;
509 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
510
511 ret = mm81x_usb_mem_read(musb, address, (u8 *)val, sizeof(*val));
512 if (ret == sizeof(*val)) {
513 *val = le32_to_cpup((__le32 *)val);
514 return 0;
515 }
516
517 dev_err(mors->dev, "usb reg32 read failed %d", ret);
518 return ret;
519 }
520
mm81x_usb_reg32_write(struct mm81x * mors,u32 address,u32 val)521 static int mm81x_usb_reg32_write(struct mm81x *mors, u32 address, u32 val)
522 {
523 int ret = 0;
524 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
525 __le32 val_le = cpu_to_le32(val);
526
527 ret = mm81x_usb_mem_write(musb, address, (u8 *)&val_le, sizeof(val_le));
528 if (ret == sizeof(val_le))
529 return 0;
530
531 dev_err(mors->dev, "usb reg32 write failed %d", ret);
532 return ret;
533 }
534
mm81x_usb_bus_enable(struct mm81x * mors,bool enable)535 static void mm81x_usb_bus_enable(struct mm81x *mors, bool enable)
536 {
537 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
538
539 if (enable)
540 usb_autopm_get_interface(musb->interface);
541 else
542 usb_autopm_put_interface(musb->interface);
543 }
544
mm81x_usb_claim_bus(struct mm81x * mors)545 static void mm81x_usb_claim_bus(struct mm81x *mors)
546 {
547 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
548
549 mutex_lock(&musb->bus_lock);
550 }
551
mm81x_usb_release_bus(struct mm81x * mors)552 static void mm81x_usb_release_bus(struct mm81x *mors)
553 {
554 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
555
556 mutex_unlock(&musb->bus_lock);
557 }
558
mm81x_usb_set_irq(struct mm81x * mors,bool enable)559 static void mm81x_usb_set_irq(struct mm81x *mors, bool enable)
560 {
561 }
562
563 static const struct mm81x_bus_ops mm81x_usb_ops = {
564 .dm_read = mm81x_usb_dm_read,
565 .dm_write = mm81x_usb_dm_write,
566 .reg32_read = mm81x_usb_reg32_read,
567 .reg32_write = mm81x_usb_reg32_write,
568 .digital_reset = mm81x_usb_ndr_reset,
569 .set_bus_enable = mm81x_usb_bus_enable,
570 .claim = mm81x_usb_claim_bus,
571 .release = mm81x_usb_release_bus,
572 .set_irq = mm81x_usb_set_irq,
573 .bulk_alignment = MM81X_BUS_DEFAULT_BULK_ALIGNMENT,
574 };
575
mm81x_usb_detect_endpoints(struct mm81x * mors,const struct usb_interface * intf)576 static int mm81x_usb_detect_endpoints(struct mm81x *mors,
577 const struct usb_interface *intf)
578 {
579 int ret;
580 unsigned int i;
581 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
582 struct usb_endpoint_descriptor *ep_desc;
583 struct usb_host_interface *intf_desc = intf->cur_altsetting;
584
585 for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
586 ep_desc = &intf_desc->endpoint[i].desc;
587
588 if (usb_endpoint_is_bulk_in(ep_desc)) {
589 if (!musb->endpoints[MM81X_EP_MEM_RD].addr) {
590 musb->endpoints[MM81X_EP_MEM_RD].addr =
591 usb_endpoint_num(ep_desc);
592 musb->endpoints[MM81X_EP_MEM_RD].size =
593 usb_endpoint_maxp(ep_desc);
594 } else if (!musb->endpoints[MM81X_EP_REG_RD].addr) {
595 musb->endpoints[MM81X_EP_REG_RD].addr =
596 usb_endpoint_num(ep_desc);
597 musb->endpoints[MM81X_EP_REG_RD].size =
598 usb_endpoint_maxp(ep_desc);
599 }
600 } else if (usb_endpoint_is_bulk_out(ep_desc)) {
601 if (!musb->endpoints[MM81X_EP_MEM_WR].addr) {
602 musb->endpoints[MM81X_EP_MEM_WR].addr =
603 usb_endpoint_num(ep_desc);
604 musb->endpoints[MM81X_EP_MEM_WR].size =
605 usb_endpoint_maxp(ep_desc);
606 } else if (!musb->endpoints[MM81X_EP_REG_WR].addr) {
607 musb->endpoints[MM81X_EP_REG_WR].addr =
608 usb_endpoint_num(ep_desc);
609 musb->endpoints[MM81X_EP_REG_WR].size =
610 usb_endpoint_maxp(ep_desc);
611 }
612 } else if (usb_endpoint_is_int_in(ep_desc)) {
613 musb->endpoints[MM81X_EP_INT].addr =
614 usb_endpoint_num(ep_desc);
615 musb->endpoints[MM81X_EP_INT].size =
616 usb_endpoint_maxp(ep_desc);
617 }
618 }
619
620 dev_dbg(mors->dev, "\tMemory Endpoint IN %s detected: %u size %u",
621 musb->endpoints[MM81X_EP_MEM_RD].addr ? "" : "not",
622 musb->endpoints[MM81X_EP_MEM_RD].addr,
623 musb->endpoints[MM81X_EP_MEM_RD].size);
624 dev_dbg(mors->dev, "\tMemory Endpoint OUT %s detected: %u size %u",
625 musb->endpoints[MM81X_EP_MEM_WR].addr ? "" : "not",
626 musb->endpoints[MM81X_EP_MEM_WR].addr,
627 musb->endpoints[MM81X_EP_MEM_WR].size);
628 dev_dbg(mors->dev, "\tRegister Endpoint IN %s detected: %u",
629 musb->endpoints[MM81X_EP_REG_RD].addr ? "" : "not",
630 musb->endpoints[MM81X_EP_REG_RD].addr);
631 dev_dbg(mors->dev, "\tRegister Endpoint OUT %s detected: %u",
632 musb->endpoints[MM81X_EP_REG_WR].addr ? "" : "not",
633 musb->endpoints[MM81X_EP_REG_WR].addr);
634 dev_dbg(mors->dev, "\tStats IN endpoint %s detected: %u",
635 musb->endpoints[MM81X_EP_INT].addr ? "" : "not",
636 musb->endpoints[MM81X_EP_INT].addr);
637
638 /* Verify we have an IN and OUT */
639 if (!(musb->endpoints[MM81X_EP_MEM_RD].addr &&
640 musb->endpoints[MM81X_EP_MEM_WR].addr))
641 return -ENODEV;
642
643 /* Verify the stats MM81X_EP_INT is detected */
644 if (!musb->endpoints[MM81X_EP_INT].addr)
645 return -ENODEV;
646
647 /* Verify minimum interrupt status read */
648 if (musb->endpoints[MM81X_EP_INT].size < 8)
649 return -ENODEV;
650
651 musb->endpoints[MM81X_EP_CMD].urb = usb_alloc_urb(0, GFP_KERNEL);
652 if (!musb->endpoints[MM81X_EP_CMD].urb) {
653 ret = -ENOMEM;
654 goto err_ep;
655 }
656
657 musb->endpoints[MM81X_EP_MEM_RD].urb = usb_alloc_urb(0, GFP_KERNEL);
658 if (!musb->endpoints[MM81X_EP_MEM_RD].urb) {
659 ret = -ENOMEM;
660 goto err_ep;
661 }
662
663 musb->endpoints[MM81X_EP_MEM_WR].urb = usb_alloc_urb(0, GFP_KERNEL);
664 if (!musb->endpoints[MM81X_EP_MEM_WR].urb) {
665 ret = -ENOMEM;
666 goto err_ep;
667 }
668
669 musb->endpoints[MM81X_EP_MEM_RD].buffer =
670 kmalloc(USB_MAX_TRANSFER_SIZE, GFP_KERNEL);
671 if (!musb->endpoints[MM81X_EP_MEM_RD].buffer) {
672 ret = -ENOMEM;
673 goto err_ep;
674 }
675
676 musb->endpoints[MM81X_EP_MEM_WR].buffer =
677 kmalloc(USB_MAX_TRANSFER_SIZE, GFP_KERNEL);
678 if (!musb->endpoints[MM81X_EP_MEM_WR].buffer) {
679 ret = -ENOMEM;
680 goto err_ep;
681 }
682
683 musb->endpoints[MM81X_EP_CMD].buffer = usb_alloc_coherent(
684 musb->udev, sizeof(struct mm81x_usb_command), GFP_KERNEL,
685 &musb->endpoints[MM81X_EP_CMD].urb->transfer_dma);
686
687 if (!musb->endpoints[MM81X_EP_CMD].buffer) {
688 ret = -ENOMEM;
689 goto err_ep;
690 }
691
692 /* Assign command to memory out end point */
693 musb->endpoints[MM81X_EP_CMD].addr =
694 musb->endpoints[MM81X_EP_MEM_WR].addr;
695 musb->endpoints[MM81X_EP_CMD].size =
696 musb->endpoints[MM81X_EP_MEM_WR].size;
697
698 return 0;
699
700 err_ep:
701 if (musb->endpoints[MM81X_EP_CMD].urb &&
702 musb->endpoints[MM81X_EP_CMD].buffer)
703 usb_free_coherent(
704 musb->udev, sizeof(struct mm81x_usb_command),
705 musb->endpoints[MM81X_EP_CMD].buffer,
706 musb->endpoints[MM81X_EP_CMD].urb->transfer_dma);
707 usb_free_urb(musb->endpoints[MM81X_EP_MEM_RD].urb);
708 usb_free_urb(musb->endpoints[MM81X_EP_CMD].urb);
709 usb_free_urb(musb->endpoints[MM81X_EP_MEM_WR].urb);
710 kfree(musb->endpoints[MM81X_EP_MEM_RD].buffer);
711 kfree(musb->endpoints[MM81X_EP_MEM_WR].buffer);
712
713 return ret;
714 }
715
mm81x_urb_cleanup(struct mm81x * mors)716 static void mm81x_urb_cleanup(struct mm81x *mors)
717 {
718 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
719 struct mm81x_usb_endpoint *int_ep = &musb->endpoints[MM81X_EP_INT];
720 struct mm81x_usb_endpoint *rd_ep = &musb->endpoints[MM81X_EP_MEM_RD];
721 struct mm81x_usb_endpoint *wr_ep = &musb->endpoints[MM81X_EP_MEM_WR];
722 struct mm81x_usb_endpoint *cmd_ep = &musb->endpoints[MM81X_EP_CMD];
723
724 usb_kill_urb(rd_ep->urb);
725 usb_kill_urb(wr_ep->urb);
726 usb_kill_urb(cmd_ep->urb);
727
728 if (int_ep->urb)
729 usb_free_coherent(musb->udev, MM81X_EP_INT_BUFFER_SIZE,
730 int_ep->buffer, int_ep->urb->transfer_dma);
731
732 if (cmd_ep->urb)
733 usb_free_coherent(musb->udev, sizeof(struct mm81x_usb_command),
734 cmd_ep->buffer, cmd_ep->urb->transfer_dma);
735
736 kfree(wr_ep->buffer);
737 kfree(rd_ep->buffer);
738
739 usb_free_urb(int_ep->urb);
740 usb_free_urb(wr_ep->urb);
741 usb_free_urb(rd_ep->urb);
742 usb_free_urb(cmd_ep->urb);
743 }
744
mm81x_usb_probe(struct usb_interface * interface,const struct usb_device_id * id)745 static int mm81x_usb_probe(struct usb_interface *interface,
746 const struct usb_device_id *id)
747 {
748 int ret;
749 struct mm81x *mors;
750 struct mm81x_usb *musb;
751
752 mors = mm81x_core_alloc(sizeof(*musb), &interface->dev);
753 if (!mors)
754 return -ENOMEM;
755
756 mors->bus_ops = &mm81x_usb_ops;
757 mors->bus_type = MM81X_BUS_TYPE_USB;
758
759 musb = (struct mm81x_usb *)mors->drv_priv;
760 musb->udev = usb_get_dev(interface_to_usbdev(interface));
761 musb->interface = usb_get_intf(interface);
762
763 mutex_init(&musb->lock);
764 mutex_init(&musb->bus_lock);
765 init_waitqueue_head(&musb->rw_in_wait);
766 usb_set_intfdata(interface, mors);
767
768 ret = mm81x_usb_detect_endpoints(mors, interface);
769 if (ret < 0)
770 goto err_core_free;
771
772 set_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags);
773
774 ret = mm81x_core_init(mors);
775 if (ret)
776 goto err_urb_cleanup;
777
778 INIT_WORK(&mors->usb_irq_work, mm81x_usb_irq_work);
779
780 ret = mm81x_usb_int_enable(mors);
781 if (ret)
782 goto err_core_deinit;
783
784 ret = mm81x_core_register(mors);
785 if (ret)
786 goto err_usb_int_stop;
787
788 /* USB requires remote wakeup functionality for suspend */
789 clear_bit(MM81X_USB_FLAG_SUSPENDED, &musb->flags);
790 musb->interface->needs_remote_wakeup = 1;
791 usb_enable_autosuspend(musb->udev);
792 pm_runtime_set_autosuspend_delay(&musb->udev->dev,
793 PM_RUNTIME_AUTOSUSPEND_DELAY_MS);
794
795 usb_autopm_get_interface(interface);
796 return 0;
797
798 err_usb_int_stop:
799 mm81x_usb_int_stop(mors);
800 err_core_deinit:
801 mm81x_core_deinit(mors);
802 err_urb_cleanup:
803 mm81x_urb_cleanup(mors);
804 err_core_free:
805 mm81x_core_free(mors);
806 usb_put_intf(interface);
807 usb_put_dev(interface_to_usbdev(interface));
808 return ret;
809 }
810
mm81x_usb_disconnect(struct usb_interface * interface)811 static void mm81x_usb_disconnect(struct usb_interface *interface)
812 {
813 struct mm81x *mors = usb_get_intfdata(interface);
814 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
815 int minor = interface->minor;
816 struct usb_device *udev = interface_to_usbdev(interface);
817
818 if (udev->state == USB_STATE_NOTATTACHED) {
819 clear_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags);
820 set_bit(MM81X_STATE_CHIP_UNRESPONSIVE, &mors->state_flags);
821 dev_dbg(mors->dev, "USB suddenly unplugged");
822 }
823
824 usb_disable_autosuspend(udev);
825
826 if (test_bit(MM81X_USB_FLAG_SUSPENDED, &musb->flags)) {
827 dev_dbg(mors->dev, "USB was suspended: release locks");
828 mm81x_usb_release_bus(mors);
829 mutex_unlock(&musb->lock);
830 }
831
832 clear_bit(MM81X_USB_FLAG_SUSPENDED, &musb->flags);
833
834 mm81x_core_unregister(mors);
835 mm81x_usb_int_stop(mors);
836 mm81x_core_deinit(mors);
837 mm81x_urb_cleanup(mors);
838 mm81x_core_free(mors);
839
840 usb_autopm_put_interface(interface);
841 usb_set_intfdata(interface, NULL);
842 dev_info(&interface->dev, "USB Morse #%d now disconnected", minor);
843 usb_put_intf(interface);
844 usb_put_dev(udev);
845 }
846
mm81x_usb_suspend(struct usb_interface * intf,pm_message_t message)847 static int mm81x_usb_suspend(struct usb_interface *intf, pm_message_t message)
848 {
849 struct mm81x *mors = usb_get_intfdata(intf);
850 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
851 struct mm81x_usb_endpoint *int_ep = &musb->endpoints[MM81X_EP_INT];
852 struct mm81x_usb_endpoint *rd_ep = &musb->endpoints[MM81X_EP_MEM_RD];
853 struct mm81x_usb_endpoint *wr_ep = &musb->endpoints[MM81X_EP_MEM_WR];
854 struct mm81x_usb_endpoint *cmd_ep = &musb->endpoints[MM81X_EP_CMD];
855
856 if (!test_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags))
857 return -ENODEV;
858
859 usb_kill_urb(int_ep->urb);
860 usb_kill_urb(rd_ep->urb);
861 usb_kill_urb(wr_ep->urb);
862 usb_kill_urb(cmd_ep->urb);
863
864 /* Locking the bus. No USB communication after this point */
865 mm81x_usb_claim_bus(mors);
866 mutex_lock(&musb->lock);
867
868 set_bit(MM81X_USB_FLAG_SUSPENDED, &musb->flags);
869 return 0;
870 }
871
mm81x_usb_resume(struct usb_interface * intf)872 static int mm81x_usb_resume(struct usb_interface *intf)
873 {
874 struct mm81x *mors = usb_get_intfdata(intf);
875 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
876 int ret;
877 struct mm81x_usb_endpoint *int_ep = &musb->endpoints[MM81X_EP_INT];
878
879 if (!test_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags))
880 return -ENODEV;
881
882 ret = usb_submit_urb(int_ep->urb, GFP_KERNEL);
883 if (ret)
884 dev_err(mors->dev, "Couldn't submit urb. Error number %d", ret);
885
886 mm81x_usb_release_bus(mors);
887 mutex_unlock(&musb->lock);
888
889 clear_bit(MM81X_USB_FLAG_SUSPENDED, &musb->flags);
890 return 0;
891 }
892
mm81x_usb_reset_resume(struct usb_interface * intf)893 static int mm81x_usb_reset_resume(struct usb_interface *intf)
894 {
895 struct mm81x *mors = usb_get_intfdata(intf);
896 struct mm81x_usb *musb = (struct mm81x_usb *)mors->drv_priv;
897 int ret;
898 struct mm81x_usb_endpoint *int_ep = &musb->endpoints[MM81X_EP_INT];
899
900 if (!test_bit(MM81X_USB_FLAG_ATTACHED, &musb->flags))
901 return -ENODEV;
902
903 ret = usb_submit_urb(int_ep->urb, GFP_KERNEL);
904 if (ret)
905 dev_err(mors->dev, "Couldn't submit urb. Error number %d", ret);
906
907 mm81x_usb_release_bus(mors);
908 mutex_unlock(&musb->lock);
909
910 clear_bit(MM81X_USB_FLAG_SUSPENDED, &musb->flags);
911
912 return 0;
913 }
914
mm81x_usb_pre_reset(struct usb_interface * intf)915 static int mm81x_usb_pre_reset(struct usb_interface *intf)
916 {
917 return 0;
918 }
919
mm81x_usb_post_reset(struct usb_interface * intf)920 static int mm81x_usb_post_reset(struct usb_interface *intf)
921 {
922 return 0;
923 }
924
925 static struct usb_driver mm81x_usb_driver = {
926 .name = "mm81x_usb",
927 .probe = mm81x_usb_probe,
928 .disconnect = mm81x_usb_disconnect,
929 .suspend = mm81x_usb_suspend,
930 .resume = mm81x_usb_resume,
931 .reset_resume = mm81x_usb_reset_resume,
932 .pre_reset = mm81x_usb_pre_reset,
933 .post_reset = mm81x_usb_post_reset,
934 .id_table = mm81x_usb_table,
935 .supports_autosuspend = 1,
936 .soft_unbind = 1,
937 };
938
939 module_usb_driver(mm81x_usb_driver);
940
941 MODULE_AUTHOR("Morse Micro");
942 MODULE_DESCRIPTION("Driver support for Morse Micro MM81X USB devices");
943 MODULE_LICENSE("Dual BSD/GPL");
944