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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 915 static int mm81x_usb_pre_reset(struct usb_interface *intf) 916 { 917 return 0; 918 } 919 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