// SPDX-License-Identifier: GPL-2.0 /* * Cadence CDNSP DRD Driver. * * Copyright (C) 2020 Cadence. * * Author: Pawel Laszczak <[email protected]> * */ #include <linux/moduleparam.h> #include <linux/dma-mapping.h> #include <linux/module.h> #include <linux/iopoll.h> #include <linux/delay.h> #include <linux/log2.h> #include <linux/slab.h> #include <linux/pci.h> #include <linux/irq.h> #include <linux/dmi.h> #include "core.h" #include "gadget-export.h" #include "drd.h" #include "cdnsp-gadget.h" #include "cdnsp-trace.h" unsigned int cdnsp_port_speed(unsigned int port_status) { … } /* * Given a port state, this function returns a value that would result in the * port being in the same state, if the value was written to the port status * control register. * Save Read Only (RO) bits and save read/write bits where * writing a 0 clears the bit and writing a 1 sets the bit (RWS). * For all other types (RW1S, RW1CS, RW, and RZ), writing a '0' has no effect. */ u32 cdnsp_port_state_to_neutral(u32 state) { … } /** * cdnsp_find_next_ext_cap - Find the offset of the extended capabilities * with capability ID id. * @base: PCI MMIO registers base address. * @start: Address at which to start looking, (0 or HCC_PARAMS to start at * beginning of list) * @id: Extended capability ID to search for. * * Returns the offset of the next matching extended capability structure. * Some capabilities can occur several times, * e.g., the EXT_CAPS_PROTOCOL, and this provides a way to find them all. */ int cdnsp_find_next_ext_cap(void __iomem *base, u32 start, int id) { … } void cdnsp_set_link_state(struct cdnsp_device *pdev, __le32 __iomem *port_regs, u32 link_state) { … } static void cdnsp_disable_port(struct cdnsp_device *pdev, __le32 __iomem *port_regs) { … } static void cdnsp_clear_port_change_bit(struct cdnsp_device *pdev, __le32 __iomem *port_regs) { … } static void cdnsp_set_chicken_bits_2(struct cdnsp_device *pdev, u32 bit) { … } static void cdnsp_clear_chicken_bits_2(struct cdnsp_device *pdev, u32 bit) { … } /* * Disable interrupts and begin the controller halting process. */ static void cdnsp_quiesce(struct cdnsp_device *pdev) { … } /* * Force controller into halt state. * * Disable any IRQs and clear the run/stop bit. * Controller will complete any current and actively pipelined transactions, and * should halt within 16 ms of the run/stop bit being cleared. * Read controller Halted bit in the status register to see when the * controller is finished. */ int cdnsp_halt(struct cdnsp_device *pdev) { … } /* * device controller died, register read returns 0xffffffff, or command never * ends. */ void cdnsp_died(struct cdnsp_device *pdev) { … } /* * Set the run bit and wait for the device to be running. */ static int cdnsp_start(struct cdnsp_device *pdev) { … } /* * Reset a halted controller. * * This resets pipelines, timers, counters, state machines, etc. * Transactions will be terminated immediately, and operational registers * will be set to their defaults. */ int cdnsp_reset(struct cdnsp_device *pdev) { … } /* * cdnsp_get_endpoint_index - Find the index for an endpoint given its * descriptor.Use the return value to right shift 1 for the bitmask. * * Index = (epnum * 2) + direction - 1, * where direction = 0 for OUT, 1 for IN. * For control endpoints, the IN index is used (OUT index is unused), so * index = (epnum * 2) + direction - 1 = (epnum * 2) + 1 - 1 = (epnum * 2) */ static unsigned int cdnsp_get_endpoint_index(const struct usb_endpoint_descriptor *desc) { … } /* * Find the flag for this endpoint (for use in the control context). Use the * endpoint index to create a bitmask. The slot context is bit 0, endpoint 0 is * bit 1, etc. */ static unsigned int cdnsp_get_endpoint_flag(const struct usb_endpoint_descriptor *desc) { … } int cdnsp_ep_enqueue(struct cdnsp_ep *pep, struct cdnsp_request *preq) { … } /* * Remove the request's TD from the endpoint ring. This may cause the * controller to stop USB transfers, potentially stopping in the middle of a * TRB buffer. The controller should pick up where it left off in the TD, * unless a Set Transfer Ring Dequeue Pointer is issued. * * The TRBs that make up the buffers for the canceled request will be "removed" * from the ring. Since the ring is a contiguous structure, they can't be * physically removed. Instead, there are two options: * * 1) If the controller is in the middle of processing the request to be * canceled, we simply move the ring's dequeue pointer past those TRBs * using the Set Transfer Ring Dequeue Pointer command. This will be * the common case, when drivers timeout on the last submitted request * and attempt to cancel. * * 2) If the controller is in the middle of a different TD, we turn the TRBs * into a series of 1-TRB transfer no-op TDs. No-ops shouldn't be chained. * The controller will need to invalidate the any TRBs it has cached after * the stop endpoint command. * * 3) The TD may have completed by the time the Stop Endpoint Command * completes, so software needs to handle that case too. * */ int cdnsp_ep_dequeue(struct cdnsp_ep *pep, struct cdnsp_request *preq) { … } static void cdnsp_zero_in_ctx(struct cdnsp_device *pdev) { … } /* Issue a configure endpoint command and wait for it to finish. */ static int cdnsp_configure_endpoint(struct cdnsp_device *pdev) { … } static void cdnsp_invalidate_ep_events(struct cdnsp_device *pdev, struct cdnsp_ep *pep) { … } int cdnsp_wait_for_cmd_compl(struct cdnsp_device *pdev) { … } int cdnsp_halt_endpoint(struct cdnsp_device *pdev, struct cdnsp_ep *pep, int value) { … } static int cdnsp_update_eps_configuration(struct cdnsp_device *pdev, struct cdnsp_ep *pep) { … } /* * This submits a Reset Device Command, which will set the device state to 0, * set the device address to 0, and disable all the endpoints except the default * control endpoint. The USB core should come back and call * cdnsp_setup_device(), and then re-set up the configuration. */ int cdnsp_reset_device(struct cdnsp_device *pdev) { … } /* * Sets the MaxPStreams field and the Linear Stream Array field. * Sets the dequeue pointer to the stream context array. */ static void cdnsp_setup_streams_ep_input_ctx(struct cdnsp_device *pdev, struct cdnsp_ep_ctx *ep_ctx, struct cdnsp_stream_info *stream_info) { … } /* * The drivers use this function to prepare a bulk endpoints to use streams. * * Don't allow the call to succeed if endpoint only supports one stream * (which means it doesn't support streams at all). */ int cdnsp_alloc_streams(struct cdnsp_device *pdev, struct cdnsp_ep *pep) { … } int cdnsp_disable_slot(struct cdnsp_device *pdev) { … } int cdnsp_enable_slot(struct cdnsp_device *pdev) { … } /* * Issue an Address Device command with BSR=0 if setup is SETUP_CONTEXT_ONLY * or with BSR = 1 if set_address is SETUP_CONTEXT_ADDRESS. */ int cdnsp_setup_device(struct cdnsp_device *pdev, enum cdnsp_setup_dev setup) { … } void cdnsp_set_usb2_hardware_lpm(struct cdnsp_device *pdev, struct usb_request *req, int enable) { … } static int cdnsp_get_frame(struct cdnsp_device *pdev) { … } static int cdnsp_gadget_ep_enable(struct usb_ep *ep, const struct usb_endpoint_descriptor *desc) { … } static int cdnsp_gadget_ep_disable(struct usb_ep *ep) { … } static struct usb_request *cdnsp_gadget_ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags) { … } static void cdnsp_gadget_ep_free_request(struct usb_ep *ep, struct usb_request *request) { … } static int cdnsp_gadget_ep_queue(struct usb_ep *ep, struct usb_request *request, gfp_t gfp_flags) { … } static int cdnsp_gadget_ep_dequeue(struct usb_ep *ep, struct usb_request *request) { … } static int cdnsp_gadget_ep_set_halt(struct usb_ep *ep, int value) { … } static int cdnsp_gadget_ep_set_wedge(struct usb_ep *ep) { … } static const struct usb_ep_ops cdnsp_gadget_ep0_ops = …; static const struct usb_ep_ops cdnsp_gadget_ep_ops = …; void cdnsp_gadget_giveback(struct cdnsp_ep *pep, struct cdnsp_request *preq, int status) { … } static struct usb_endpoint_descriptor cdnsp_gadget_ep0_desc = …; static int cdnsp_run(struct cdnsp_device *pdev, enum usb_device_speed speed) { … } static int cdnsp_gadget_udc_start(struct usb_gadget *g, struct usb_gadget_driver *driver) { … } /* * Update Event Ring Dequeue Pointer: * - When all events have finished * - To avoid "Event Ring Full Error" condition */ void cdnsp_update_erst_dequeue(struct cdnsp_device *pdev, union cdnsp_trb *event_ring_deq, u8 clear_ehb) { … } static void cdnsp_clear_cmd_ring(struct cdnsp_device *pdev) { … } static void cdnsp_consume_all_events(struct cdnsp_device *pdev) { … } static void cdnsp_stop(struct cdnsp_device *pdev) { … } /* * Stop controller. * This function is called by the gadget core when the driver is removed. * Disable slot, disable IRQs, and quiesce the controller. */ static int cdnsp_gadget_udc_stop(struct usb_gadget *g) { … } static int cdnsp_gadget_get_frame(struct usb_gadget *g) { … } static void __cdnsp_gadget_wakeup(struct cdnsp_device *pdev) { … } static int cdnsp_gadget_wakeup(struct usb_gadget *g) { … } static int cdnsp_gadget_set_selfpowered(struct usb_gadget *g, int is_selfpowered) { … } static int cdnsp_gadget_pullup(struct usb_gadget *gadget, int is_on) { … } static const struct usb_gadget_ops cdnsp_gadget_ops = …; static void cdnsp_get_ep_buffering(struct cdnsp_device *pdev, struct cdnsp_ep *pep) { … } static int cdnsp_gadget_init_endpoints(struct cdnsp_device *pdev) { … } static void cdnsp_gadget_free_endpoints(struct cdnsp_device *pdev) { … } void cdnsp_disconnect_gadget(struct cdnsp_device *pdev) { … } void cdnsp_suspend_gadget(struct cdnsp_device *pdev) { … } void cdnsp_resume_gadget(struct cdnsp_device *pdev) { … } void cdnsp_irq_reset(struct cdnsp_device *pdev) { … } static void cdnsp_get_rev_cap(struct cdnsp_device *pdev) { … } static int cdnsp_gen_setup(struct cdnsp_device *pdev) { … } static int __cdnsp_gadget_init(struct cdns *cdns) { … } static void cdnsp_gadget_exit(struct cdns *cdns) { … } static int cdnsp_gadget_suspend(struct cdns *cdns, bool do_wakeup) { … } static int cdnsp_gadget_resume(struct cdns *cdns, bool hibernated) { … } /** * cdnsp_gadget_init - initialize device structure * @cdns: cdnsp instance * * This function initializes the gadget. */ int cdnsp_gadget_init(struct cdns *cdns) { … }
Codebase Browser
linux