| #include "headers.h" | |
| static int adapter_err_occurred(const struct bcm_interface_adapter *ad) | |
| { | |
| if (ad->psAdapter->device_removed == TRUE) { | |
| BCM_DEBUG_PRINT(ad->psAdapter, DBG_TYPE_PRINTK, 0, 0, | |
| "Device got removed"); | |
| return -ENODEV; | |
| } | |
| if ((ad->psAdapter->StopAllXaction == TRUE) && | |
| (ad->psAdapter->chip_id >= T3LPB)) { | |
| BCM_DEBUG_PRINT(ad->psAdapter, DBG_TYPE_OTHERS, RDM, | |
| DBG_LVL_ALL, | |
| "Currently Xaction is not allowed on the bus"); | |
| return -EACCES; | |
| } | |
| if (ad->bSuspended == TRUE || ad->bPreparingForBusSuspend == TRUE) { | |
| BCM_DEBUG_PRINT(ad->psAdapter, DBG_TYPE_OTHERS, RDM, | |
| DBG_LVL_ALL, | |
| "Bus is in suspended states hence RDM not allowed.."); | |
| return -EACCES; | |
| } | |
| return 0; | |
| } | |
| int InterfaceRDM(struct bcm_interface_adapter *psIntfAdapter, | |
| unsigned int addr, | |
| void *buff, | |
| int len) | |
| { | |
| int bytes; | |
| int err = 0; | |
| if (!psIntfAdapter) | |
| return -EINVAL; | |
| err = adapter_err_occurred(psIntfAdapter); | |
| if (err) | |
| return err; | |
| psIntfAdapter->psAdapter->DeviceAccess = TRUE; | |
| bytes = usb_control_msg(psIntfAdapter->udev, | |
| usb_rcvctrlpipe(psIntfAdapter->udev, 0), | |
| 0x02, | |
| 0xC2, | |
| (addr & 0xFFFF), | |
| ((addr >> 16) & 0xFFFF), | |
| buff, | |
| len, | |
| 5000); | |
| if (-ENODEV == bytes) | |
| psIntfAdapter->psAdapter->device_removed = TRUE; | |
| if (bytes < 0) | |
| BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_OTHERS, RDM, | |
| DBG_LVL_ALL, "RDM failed status :%d", bytes); | |
| else | |
| BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_OTHERS, RDM, | |
| DBG_LVL_ALL, "RDM sent %d", bytes); | |
| psIntfAdapter->psAdapter->DeviceAccess = false; | |
| return bytes; | |
| } | |
| int InterfaceWRM(struct bcm_interface_adapter *psIntfAdapter, | |
| unsigned int addr, | |
| void *buff, | |
| int len) | |
| { | |
| int retval = 0; | |
| int err = 0; | |
| if (!psIntfAdapter) | |
| return -EINVAL; | |
| err = adapter_err_occurred(psIntfAdapter); | |
| if (err) | |
| return err; | |
| psIntfAdapter->psAdapter->DeviceAccess = TRUE; | |
| retval = usb_control_msg(psIntfAdapter->udev, | |
| usb_sndctrlpipe(psIntfAdapter->udev, 0), | |
| 0x01, | |
| 0x42, | |
| (addr & 0xFFFF), | |
| ((addr >> 16) & 0xFFFF), | |
| buff, | |
| len, | |
| 5000); | |
| if (-ENODEV == retval) | |
| psIntfAdapter->psAdapter->device_removed = TRUE; | |
| if (retval < 0) { | |
| BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_OTHERS, WRM, | |
| DBG_LVL_ALL, "WRM failed status :%d", retval); | |
| psIntfAdapter->psAdapter->DeviceAccess = false; | |
| return retval; | |
| } else { | |
| psIntfAdapter->psAdapter->DeviceAccess = false; | |
| BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_OTHERS, WRM, | |
| DBG_LVL_ALL, "WRM sent %d", retval); | |
| return STATUS_SUCCESS; | |
| } | |
| } | |
| int BcmRDM(void *arg, | |
| unsigned int addr, | |
| void *buff, | |
| int len) | |
| { | |
| return InterfaceRDM((struct bcm_interface_adapter *)arg, addr, buff, | |
| len); | |
| } | |
| int BcmWRM(void *arg, | |
| unsigned int addr, | |
| void *buff, | |
| int len) | |
| { | |
| return InterfaceWRM((struct bcm_interface_adapter *)arg, addr, buff, | |
| len); | |
| } | |
| int Bcm_clear_halt_of_endpoints(struct bcm_mini_adapter *Adapter) | |
| { | |
| struct bcm_interface_adapter *psIntfAdapter = | |
| (struct bcm_interface_adapter *)(Adapter->pvInterfaceAdapter); | |
| int status = STATUS_SUCCESS; | |
| /* | |
| * usb_clear_halt - tells device to clear endpoint halt/stall condition | |
| * @dev: device whose endpoint is halted | |
| * @pipe: endpoint "pipe" being cleared | |
| * @ Context: !in_interrupt () | |
| * | |
| * usb_clear_halt is the synchrnous call and returns 0 on success else | |
| * returns with error code. | |
| * This is used to clear halt conditions for bulk and interrupt | |
| * endpoints only. | |
| * Control and isochronous endpoints never halts. | |
| * | |
| * Any URBs queued for such an endpoint should normally be unlinked by | |
| * the driver before clearing the halt condition. | |
| * | |
| */ | |
| /* Killing all the submitted urbs to different end points. */ | |
| Bcm_kill_all_URBs(psIntfAdapter); | |
| /* clear the halted/stalled state for every end point */ | |
| status = usb_clear_halt(psIntfAdapter->udev, | |
| psIntfAdapter->sIntrIn.int_in_pipe); | |
| if (status != STATUS_SUCCESS) | |
| BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, INTF_INIT, | |
| DBG_LVL_ALL, | |
| "Unable to Clear Halt of Interrupt IN end point. :%d ", | |
| status); | |
| status = usb_clear_halt(psIntfAdapter->udev, | |
| psIntfAdapter->sBulkIn.bulk_in_pipe); | |
| if (status != STATUS_SUCCESS) | |
| BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, INTF_INIT, | |
| DBG_LVL_ALL, | |
| "Unable to Clear Halt of Bulk IN end point. :%d ", | |
| status); | |
| status = usb_clear_halt(psIntfAdapter->udev, | |
| psIntfAdapter->sBulkOut.bulk_out_pipe); | |
| if (status != STATUS_SUCCESS) | |
| BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, INTF_INIT, | |
| DBG_LVL_ALL, | |
| "Unable to Clear Halt of Bulk OUT end point. :%d ", | |
| status); | |
| return status; | |
| } | |
| void Bcm_kill_all_URBs(struct bcm_interface_adapter *psIntfAdapter) | |
| { | |
| struct urb *tempUrb = NULL; | |
| unsigned int i; | |
| /* | |
| * usb_kill_urb - cancel a transfer request and wait for it to finish | |
| * @urb: pointer to URB describing a previously submitted request, | |
| * returns nothing as it is void returned API. | |
| * | |
| * This routine cancels an in-progress request. It is guaranteed that | |
| * upon return all completion handlers will have finished and the URB | |
| * will be totally idle and available for reuse | |
| * | |
| * This routine may not be used in an interrupt context (such as a | |
| * bottom half or a completion handler), or when holding a spinlock, or | |
| * in other situations where the caller can't schedule(). | |
| * | |
| */ | |
| /* Cancel submitted Interrupt-URB's */ | |
| if (psIntfAdapter->psInterruptUrb) { | |
| if (psIntfAdapter->psInterruptUrb->status == -EINPROGRESS) | |
| usb_kill_urb(psIntfAdapter->psInterruptUrb); | |
| } | |
| /* Cancel All submitted TX URB's */ | |
| for (i = 0; i < MAXIMUM_USB_TCB; i++) { | |
| tempUrb = psIntfAdapter->asUsbTcb[i].urb; | |
| if (tempUrb) { | |
| if (tempUrb->status == -EINPROGRESS) | |
| usb_kill_urb(tempUrb); | |
| } | |
| } | |
| for (i = 0; i < MAXIMUM_USB_RCB; i++) { | |
| tempUrb = psIntfAdapter->asUsbRcb[i].urb; | |
| if (tempUrb) { | |
| if (tempUrb->status == -EINPROGRESS) | |
| usb_kill_urb(tempUrb); | |
| } | |
| } | |
| atomic_set(&psIntfAdapter->uNumTcbUsed, 0); | |
| atomic_set(&psIntfAdapter->uCurrTcb, 0); | |
| atomic_set(&psIntfAdapter->uNumRcbUsed, 0); | |
| atomic_set(&psIntfAdapter->uCurrRcb, 0); | |
| } | |
| void putUsbSuspend(struct work_struct *work) | |
| { | |
| struct bcm_interface_adapter *psIntfAdapter = NULL; | |
| struct usb_interface *intf = NULL; | |
| psIntfAdapter = container_of(work, struct bcm_interface_adapter, | |
| usbSuspendWork); | |
| intf = psIntfAdapter->interface; | |
| if (psIntfAdapter->bSuspended == false) | |
| usb_autopm_put_interface(intf); | |
| } | |