UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

xhci: dbc: simplify dbc requests allocation and queueing 

Don't pass endpoint pointer, dbctty should not be aware of
struct dbc_ep, knowing the direction is enough.

Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Link: https://lore.kernel.org/r/20200723144530.9992-23-mathias.nyman@linux.intel.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Mathias Nyman 2020-07-23 17:45:25 +03:00 committed by Greg Kroah-Hartman
parent 11e229a758
commit e0aa56dc7b
3 changed files with 52 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
drivers/usb/host/xhci-dbgcap.c
View File

@ -135,8 +135,7 @@ static void xhci_dbc_giveback(struct dbc_request *req, int status)
__releases(&dbc->lock)
__acquires(&dbc->lock)
{
struct dbc_ep *dep = req->dep;
struct xhci_dbc *dbc = dep->dbc;
struct xhci_dbc *dbc = req->dbc;
struct device *dev = dbc->dev;
list_del_init(&req->list_pending);
@ -151,7 +150,7 @@ static void xhci_dbc_giveback(struct dbc_request *req, int status)
dma_unmap_single(dev,
req->dma,
req->length,
dbc_ep_dma_direction(dep));
dbc_ep_dma_direction(req));
/* Give back the transfer request: */
spin_unlock(&dbc->lock);
@ -187,18 +186,25 @@ static void xhci_dbc_flush_requests(struct xhci_dbc *dbc)
}
struct dbc_request *
dbc_alloc_request(struct dbc_ep *dep, gfp_t gfp_flags)
dbc_alloc_request(struct xhci_dbc *dbc, unsigned int direction, gfp_t flags)
{
struct dbc_request *req;
req = kzalloc(sizeof(*req), gfp_flags);
if (direction != BULK_IN &&
direction != BULK_OUT)
return NULL;
if (!dbc)
return NULL;
req = kzalloc(sizeof(*req), flags);
if (!req)
return NULL;
req->dep = dep;
req->dbc = dbc;
INIT_LIST_HEAD(&req->list_pending);
INIT_LIST_HEAD(&req->list_pool);
req->direction = dep->direction;
req->direction = direction;
trace_xhci_dbc_alloc_request(req);
@ -206,7 +212,7 @@ dbc_alloc_request(struct dbc_ep *dep, gfp_t gfp_flags)
}
void
dbc_free_request(struct dbc_ep *dep, struct dbc_request *req)
dbc_free_request(struct dbc_request *req)
{
trace_xhci_dbc_free_request(req);
@ -242,7 +248,7 @@ static int xhci_dbc_queue_bulk_tx(struct dbc_ep *dep,
u64 addr;
union xhci_trb *trb;
unsigned int num_trbs;
struct xhci_dbc *dbc = dep->dbc;
struct xhci_dbc *dbc = req->dbc;
struct xhci_ring *ring = dep->ring;
u32 length, control, cycle;
@ -286,11 +292,12 @@ static int xhci_dbc_queue_bulk_tx(struct dbc_ep *dep,
}
static int
dbc_ep_do_queue(struct dbc_ep *dep, struct dbc_request *req)
dbc_ep_do_queue(struct dbc_request *req)
{
int ret;
struct xhci_dbc *dbc = dep->dbc;
struct xhci_dbc *dbc = req->dbc;
struct device *dev = dbc->dev;
struct dbc_ep *dep = &dbc->eps[req->direction];
if (!req->length || !req->buf)
return -EINVAL;
@ -322,16 +329,22 @@ dbc_ep_do_queue(struct dbc_ep *dep, struct dbc_request *req)
return 0;
}
int dbc_ep_queue(struct dbc_ep *dep, struct dbc_request *req,
gfp_t gfp_flags)
int dbc_ep_queue(struct dbc_request *req)
{
unsigned long flags;
struct xhci_dbc *dbc = dep->dbc;
struct xhci_dbc *dbc = req->dbc;
int ret = -ESHUTDOWN;
if (!dbc)
return -ENODEV;
if (req->direction != BULK_IN &&
req->direction != BULK_OUT)
return -EINVAL;
spin_lock_irqsave(&dbc->lock, flags);
if (dbc->state == DS_CONFIGURED)
ret = dbc_ep_do_queue(dep, req);
ret = dbc_ep_do_queue(req);
spin_unlock_irqrestore(&dbc->lock, flags);
mod_delayed_work(system_wq, &dbc->event_work, 0);

12
drivers/usb/host/xhci-dbgcap.h
View File

@ -88,7 +88,7 @@ struct dbc_ep {
struct xhci_dbc *dbc;
struct list_head list_pending;
struct xhci_ring *ring;
unsigned direction:1;
unsigned int direction:1;
};
#define DBC_QUEUE_SIZE 16
@ -147,7 +147,7 @@ struct dbc_request {
int status;
unsigned int actual;
struct dbc_ep *dep;
struct xhci_dbc *dbc;
struct list_head list_pending;
dma_addr_t trb_dma;
union xhci_trb *trb;
@ -196,9 +196,11 @@ int xhci_dbc_tty_register_driver(struct xhci_hcd *xhci);
void xhci_dbc_tty_unregister_driver(void);
int xhci_dbc_tty_register_device(struct xhci_dbc *dbc);
void xhci_dbc_tty_unregister_device(struct xhci_dbc *dbc);
struct dbc_request *dbc_alloc_request(struct dbc_ep *dep, gfp_t gfp_flags);
void dbc_free_request(struct dbc_ep *dep, struct dbc_request *req);
int dbc_ep_queue(struct dbc_ep *dep, struct dbc_request *req, gfp_t gfp_flags);
struct dbc_request *dbc_alloc_request(struct xhci_dbc *dbc,
unsigned int direction,
gfp_t flags);
void dbc_free_request(struct dbc_request *req);
int dbc_ep_queue(struct dbc_request *req);
#ifdef CONFIG_PM
int xhci_dbc_suspend(struct xhci_hcd *xhci);
int xhci_dbc_resume(struct xhci_hcd *xhci);

33
drivers/usb/host/xhci-dbgtty.c
View File

@ -48,7 +48,7 @@ static int dbc_start_tx(struct dbc_port *port)
list_del(&req->list_pool);
spin_unlock(&port->port_lock);
status = dbc_ep_queue(port->out, req, GFP_ATOMIC);
status = dbc_ep_queue(req);
spin_lock(&port->port_lock);
if (status) {
@ -80,7 +80,7 @@ static void dbc_start_rx(struct dbc_port *port)
req->length = DBC_MAX_PACKET;
spin_unlock(&port->port_lock);
status = dbc_ep_queue(port->in, req, GFP_ATOMIC);
status = dbc_ep_queue(req);
spin_lock(&port->port_lock);
if (status) {
@ -123,28 +123,29 @@ static void dbc_write_complete(struct xhci_dbc *dbc, struct dbc_request *req)
spin_unlock_irqrestore(&port->port_lock, flags);
}
static void xhci_dbc_free_req(struct dbc_ep *dep, struct dbc_request *req)
static void xhci_dbc_free_req(struct dbc_request *req)
{
kfree(req->buf);
dbc_free_request(dep, req);
dbc_free_request(req);
}
static int
xhci_dbc_alloc_requests(struct dbc_ep *dep, struct list_head *head,
xhci_dbc_alloc_requests(struct xhci_dbc *dbc, unsigned int direction,
struct list_head *head,
void (*fn)(struct xhci_dbc *, struct dbc_request *))
{
int i;
struct dbc_request *req;
for (i = 0; i < DBC_QUEUE_SIZE; i++) {
req = dbc_alloc_request(dep, GFP_KERNEL);
req = dbc_alloc_request(dbc, direction, GFP_KERNEL);
if (!req)
break;
req->length = DBC_MAX_PACKET;
req->buf = kmalloc(req->length, GFP_KERNEL);
if (!req->buf) {
dbc_free_request(dep, req);
dbc_free_request(req);
break;
}
@ -156,14 +157,14 @@ xhci_dbc_alloc_requests(struct dbc_ep *dep, struct list_head *head,
}
static void
xhci_dbc_free_requests(struct dbc_ep *dep, struct list_head *head)
xhci_dbc_free_requests(struct list_head *head)
{
struct dbc_request *req;
while (!list_empty(head)) {
req = list_entry(head->next, struct dbc_request, list_pool);
list_del(&req->list_pool);
xhci_dbc_free_req(dep, req);
xhci_dbc_free_req(req);
}
}
@ -456,12 +457,12 @@ int xhci_dbc_tty_register_device(struct xhci_dbc *dbc)
if (ret)
goto buf_alloc_fail;
ret = xhci_dbc_alloc_requests(port->in, &port->read_pool,
ret = xhci_dbc_alloc_requests(dbc, BULK_IN, &port->read_pool,
dbc_read_complete);
if (ret)
goto request_fail;
ret = xhci_dbc_alloc_requests(port->out, &port->write_pool,
ret = xhci_dbc_alloc_requests(dbc, BULK_OUT, &port->write_pool,
dbc_write_complete);
if (ret)
goto request_fail;
@ -471,8 +472,8 @@ int xhci_dbc_tty_register_device(struct xhci_dbc *dbc)
return 0;
request_fail:
xhci_dbc_free_requests(port->in, &port->read_pool);
xhci_dbc_free_requests(port->out, &port->write_pool);
xhci_dbc_free_requests(&port->read_pool);
xhci_dbc_free_requests(&port->write_pool);
kfifo_free(&port->write_fifo);
buf_alloc_fail:
@ -495,7 +496,7 @@ void xhci_dbc_tty_unregister_device(struct xhci_dbc *dbc)
port->registered = false;
kfifo_free(&port->write_fifo);
xhci_dbc_free_requests(get_out_ep(dbc), &port->read_pool);
xhci_dbc_free_requests(get_out_ep(dbc), &port->read_queue);
xhci_dbc_free_requests(get_in_ep(dbc), &port->write_pool);
xhci_dbc_free_requests(&port->read_pool);
xhci_dbc_free_requests(&port->read_queue);
xhci_dbc_free_requests(&port->write_pool);
}