lin
2025-04-16 903fc4b2d160641e35840da17820a65baa59dc20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/*
 * Thunderbolt Cactus Ridge driver - NHI driver
 *
 * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
 */
 
#ifndef DSL3510_H_
#define DSL3510_H_
 
#include <linux/mutex.h>
#include <linux/workqueue.h>
 
/**
 * struct tb_nhi - thunderbolt native host interface
 */
struct tb_nhi {
   struct mutex lock; /*
               * Must be held during ring creation/destruction.
               * Is acquired by interrupt_work when dispatching
               * interrupts to individual rings.
               **/
   struct pci_dev *pdev;
   void __iomem *iobase;
   struct tb_ring **tx_rings;
   struct tb_ring **rx_rings;
   struct work_struct interrupt_work;
   u32 hop_count; /* Number of rings (end point hops) supported by NHI. */
};
 
/**
 * struct tb_ring - thunderbolt TX or RX ring associated with a NHI
 */
struct tb_ring {
   struct mutex lock; /* must be acquired after nhi->lock */
   struct tb_nhi *nhi;
   int size;
   int hop;
   int head; /* write next descriptor here */
   int tail; /* complete next descriptor here */
   struct ring_desc *descriptors;
   dma_addr_t descriptors_dma;
   struct list_head queue;
   struct list_head in_flight;
   struct work_struct work;
   bool is_tx:1; /* rx otherwise */
   bool running:1;
};
 
struct ring_frame;
typedef void (*ring_cb)(struct tb_ring*, struct ring_frame*, bool canceled);
 
/**
 * struct ring_frame - for use with ring_rx/ring_tx
 */
struct ring_frame {
   dma_addr_t buffer_phy;
   ring_cb callback;
   struct list_head list;
   u32 size:12; /* TX: in, RX: out*/
   u32 flags:12; /* RX: out */
   u32 eof:4; /* TX:in, RX: out */
   u32 sof:4; /* TX:in, RX: out */
};
 
#define TB_FRAME_SIZE 0x100    /* minimum size for ring_rx */
 
struct tb_ring *ring_alloc_tx(struct tb_nhi *nhi, int hop, int size);
struct tb_ring *ring_alloc_rx(struct tb_nhi *nhi, int hop, int size);
void ring_start(struct tb_ring *ring);
void ring_stop(struct tb_ring *ring);
void ring_free(struct tb_ring *ring);
 
int __ring_enqueue(struct tb_ring *ring, struct ring_frame *frame);
 
/**
 * ring_rx() - enqueue a frame on an RX ring
 *
 * frame->buffer, frame->buffer_phy and frame->callback have to be set. The
 * buffer must contain at least TB_FRAME_SIZE bytes.
 *
 * frame->callback will be invoked with frame->size, frame->flags, frame->eof,
 * frame->sof set once the frame has been received.
 *
 * If ring_stop is called after the packet has been enqueued frame->callback
 * will be called with canceled set to true.
 *
 * Return: Returns ESHUTDOWN if ring_stop has been called. Zero otherwise.
 */
static inline int ring_rx(struct tb_ring *ring, struct ring_frame *frame)
{
   WARN_ON(ring->is_tx);
   return __ring_enqueue(ring, frame);
}
 
/**
 * ring_tx() - enqueue a frame on an TX ring
 *
 * frame->buffer, frame->buffer_phy, frame->callback, frame->size, frame->eof
 * and frame->sof have to be set.
 *
 * frame->callback will be invoked with once the frame has been transmitted.
 *
 * If ring_stop is called after the packet has been enqueued frame->callback
 * will be called with canceled set to true.
 *
 * Return: Returns ESHUTDOWN if ring_stop has been called. Zero otherwise.
 */
static inline int ring_tx(struct tb_ring *ring, struct ring_frame *frame)
{
   WARN_ON(!ring->is_tx);
   return __ring_enqueue(ring, frame);
}
 
#endif