1 /* SPDX-License-Identifier: GPL-2.0 */ 1 /* SPDX-License-Identifier: GPL-2.0 */
2 #undef TRACE_SYSTEM 2 #undef TRACE_SYSTEM
3 #define TRACE_SYSTEM spi 3 #define TRACE_SYSTEM spi
4 4
5 #if !defined(_TRACE_SPI_H) || defined(TRACE_HE 5 #if !defined(_TRACE_SPI_H) || defined(TRACE_HEADER_MULTI_READ)
6 #define _TRACE_SPI_H 6 #define _TRACE_SPI_H
7 7
8 #include <linux/ktime.h> 8 #include <linux/ktime.h>
9 #include <linux/tracepoint.h> 9 #include <linux/tracepoint.h>
10 10
11 DECLARE_EVENT_CLASS(spi_controller, 11 DECLARE_EVENT_CLASS(spi_controller,
12 12
13 TP_PROTO(struct spi_controller *contro 13 TP_PROTO(struct spi_controller *controller),
14 14
15 TP_ARGS(controller), 15 TP_ARGS(controller),
16 16
17 TP_STRUCT__entry( 17 TP_STRUCT__entry(
18 __field( int, 18 __field( int, bus_num )
19 ), 19 ),
20 20
21 TP_fast_assign( 21 TP_fast_assign(
22 __entry->bus_num = controller- 22 __entry->bus_num = controller->bus_num;
23 ), 23 ),
24 24
25 TP_printk("spi%d", (int)__entry->bus_n 25 TP_printk("spi%d", (int)__entry->bus_num)
26 26
27 ); 27 );
28 28
29 DEFINE_EVENT(spi_controller, spi_controller_id 29 DEFINE_EVENT(spi_controller, spi_controller_idle,
30 30
31 TP_PROTO(struct spi_controller *contro 31 TP_PROTO(struct spi_controller *controller),
32 32
33 TP_ARGS(controller) 33 TP_ARGS(controller)
34 34
35 ); 35 );
36 36
37 DEFINE_EVENT(spi_controller, spi_controller_bu 37 DEFINE_EVENT(spi_controller, spi_controller_busy,
38 38
39 TP_PROTO(struct spi_controller *contro 39 TP_PROTO(struct spi_controller *controller),
40 40
41 TP_ARGS(controller) 41 TP_ARGS(controller)
42 42
43 ); 43 );
44 44
45 TRACE_EVENT(spi_setup, <<
46 TP_PROTO(struct spi_device *spi, int s <<
47 TP_ARGS(spi, status), <<
48 <<
49 TP_STRUCT__entry( <<
50 __field(int, bus_num) <<
51 __field(int, chip_select) <<
52 __field(unsigned long, mode) <<
53 __field(unsigned int, bits_per <<
54 __field(unsigned int, max_spee <<
55 __field(int, status) <<
56 ), <<
57 <<
58 TP_fast_assign( <<
59 __entry->bus_num = spi->contro <<
60 __entry->chip_select = spi_ge <<
61 __entry->mode = spi->mode; <<
62 __entry->bits_per_word = spi-> <<
63 __entry->max_speed_hz = spi->m <<
64 __entry->status = status; <<
65 ), <<
66 <<
67 TP_printk("spi%d.%d setup mode %lu, %s <<
68 __entry->bus_num, __entry->c <<
69 (__entry->mode & SPI_MODE_X_ <<
70 (__entry->mode & SPI_CS_HIGH <<
71 (__entry->mode & SPI_LSB_FIR <<
72 (__entry->mode & SPI_3WIRE) <<
73 (__entry->mode & SPI_LOOP) ? <<
74 __entry->bits_per_word, __en <<
75 __entry->status) <<
76 ); <<
77 <<
78 TRACE_EVENT(spi_set_cs, <<
79 TP_PROTO(struct spi_device *spi, bool <<
80 TP_ARGS(spi, enable), <<
81 <<
82 TP_STRUCT__entry( <<
83 __field(int, bus_num) <<
84 __field(int, chip_select) <<
85 __field(unsigned long, mode) <<
86 __field(bool, enable) <<
87 ), <<
88 <<
89 TP_fast_assign( <<
90 __entry->bus_num = spi->contro <<
91 __entry->chip_select = spi_get <<
92 __entry->mode = spi->mode; <<
93 __entry->enable = enable; <<
94 ), <<
95 <<
96 TP_printk("spi%d.%d %s%s", <<
97 __entry->bus_num, __entry->c <<
98 __entry->enable ? "activate" <<
99 (__entry->mode & SPI_CS_HIGH <<
100 ); <<
101 <<
102 DECLARE_EVENT_CLASS(spi_message, 45 DECLARE_EVENT_CLASS(spi_message,
103 46
104 TP_PROTO(struct spi_message *msg), 47 TP_PROTO(struct spi_message *msg),
105 48
106 TP_ARGS(msg), 49 TP_ARGS(msg),
107 50
108 TP_STRUCT__entry( 51 TP_STRUCT__entry(
109 __field( int, 52 __field( int, bus_num )
110 __field( int, 53 __field( int, chip_select )
111 __field( struct spi_mes 54 __field( struct spi_message *, msg )
112 ), 55 ),
113 56
114 TP_fast_assign( 57 TP_fast_assign(
115 __entry->bus_num = msg->spi->c 58 __entry->bus_num = msg->spi->controller->bus_num;
116 __entry->chip_select = spi_get !! 59 __entry->chip_select = msg->spi->chip_select;
117 __entry->msg = msg; 60 __entry->msg = msg;
118 ), 61 ),
119 62
120 TP_printk("spi%d.%d %p", (int)__entry- 63 TP_printk("spi%d.%d %p", (int)__entry->bus_num,
121 (int)__entry->chip_select, 64 (int)__entry->chip_select,
122 (struct spi_message *)__entr 65 (struct spi_message *)__entry->msg)
123 ); 66 );
124 67
125 DEFINE_EVENT(spi_message, spi_message_submit, 68 DEFINE_EVENT(spi_message, spi_message_submit,
126 69
127 TP_PROTO(struct spi_message *msg), 70 TP_PROTO(struct spi_message *msg),
128 71
129 TP_ARGS(msg) 72 TP_ARGS(msg)
130 73
131 ); 74 );
132 75
133 DEFINE_EVENT(spi_message, spi_message_start, 76 DEFINE_EVENT(spi_message, spi_message_start,
134 77
135 TP_PROTO(struct spi_message *msg), 78 TP_PROTO(struct spi_message *msg),
136 79
137 TP_ARGS(msg) 80 TP_ARGS(msg)
138 81
139 ); 82 );
140 83
141 TRACE_EVENT(spi_message_done, 84 TRACE_EVENT(spi_message_done,
142 85
143 TP_PROTO(struct spi_message *msg), 86 TP_PROTO(struct spi_message *msg),
144 87
145 TP_ARGS(msg), 88 TP_ARGS(msg),
146 89
147 TP_STRUCT__entry( 90 TP_STRUCT__entry(
148 __field( int, 91 __field( int, bus_num )
149 __field( int, 92 __field( int, chip_select )
150 __field( struct spi_mes 93 __field( struct spi_message *, msg )
151 __field( unsigned, 94 __field( unsigned, frame )
152 __field( unsigned, 95 __field( unsigned, actual )
153 ), 96 ),
154 97
155 TP_fast_assign( 98 TP_fast_assign(
156 __entry->bus_num = msg->spi->c 99 __entry->bus_num = msg->spi->controller->bus_num;
157 __entry->chip_select = spi_get !! 100 __entry->chip_select = msg->spi->chip_select;
158 __entry->msg = msg; 101 __entry->msg = msg;
159 __entry->frame = msg->frame_le 102 __entry->frame = msg->frame_length;
160 __entry->actual = msg->actual_ 103 __entry->actual = msg->actual_length;
161 ), 104 ),
162 105
163 TP_printk("spi%d.%d %p len=%u/%u", (in 106 TP_printk("spi%d.%d %p len=%u/%u", (int)__entry->bus_num,
164 (int)__entry->chip_select, 107 (int)__entry->chip_select,
165 (struct spi_message *)__entr 108 (struct spi_message *)__entry->msg,
166 (unsigned)__entry->actual, ( 109 (unsigned)__entry->actual, (unsigned)__entry->frame)
167 ); 110 );
168 111
169 /* <<
170 * Consider a buffer valid if non-NULL and if <<
171 * that only exist to work with controllers th <<
172 * SPI_CONTROLLER_MUST_RX. <<
173 */ <<
174 #define spi_valid_txbuf(msg, xfer) \ <<
175 (xfer->tx_buf && xfer->tx_buf != msg-> <<
176 #define spi_valid_rxbuf(msg, xfer) \ <<
177 (xfer->rx_buf && xfer->rx_buf != msg-> <<
178 <<
179 DECLARE_EVENT_CLASS(spi_transfer, 112 DECLARE_EVENT_CLASS(spi_transfer,
180 113
181 TP_PROTO(struct spi_message *msg, stru 114 TP_PROTO(struct spi_message *msg, struct spi_transfer *xfer),
182 115
183 TP_ARGS(msg, xfer), 116 TP_ARGS(msg, xfer),
184 117
185 TP_STRUCT__entry( 118 TP_STRUCT__entry(
186 __field( int, 119 __field( int, bus_num )
187 __field( int, 120 __field( int, chip_select )
188 __field( struct spi_tra 121 __field( struct spi_transfer *, xfer )
189 __field( int, 122 __field( int, len )
190 __dynamic_array(u8, rx_buf, <<
191 spi_valid_rxbu <<
192 (xfer- <<
193 __dynamic_array(u8, tx_buf, <<
194 spi_valid_txbu <<
195 (xfer- <<
196 ), 123 ),
197 124
198 TP_fast_assign( 125 TP_fast_assign(
199 __entry->bus_num = msg->spi->c 126 __entry->bus_num = msg->spi->controller->bus_num;
200 __entry->chip_select = spi_get !! 127 __entry->chip_select = msg->spi->chip_select;
201 __entry->xfer = xfer; 128 __entry->xfer = xfer;
202 __entry->len = xfer->len; 129 __entry->len = xfer->len;
203 <<
204 if (spi_valid_txbuf(msg, xfer) <<
205 memcpy(__get_dynamic_a <<
206 xfer->tx_buf, _ <<
207 <<
208 if (spi_valid_rxbuf(msg, xfer) <<
209 memcpy(__get_dynamic_a <<
210 xfer->rx_buf, _ <<
211 ), 130 ),
212 131
213 TP_printk("spi%d.%d %p len=%d tx=[%*ph !! 132 TP_printk("spi%d.%d %p len=%d", (int)__entry->bus_num,
214 __entry->bus_num, __entry->c !! 133 (int)__entry->chip_select,
215 __entry->xfer, __entry->len, !! 134 (struct spi_message *)__entry->xfer,
216 __get_dynamic_array_len(tx_b !! 135 (int)__entry->len)
217 __get_dynamic_array_len(rx_b <<
218 ); 136 );
219 137
220 DEFINE_EVENT(spi_transfer, spi_transfer_start, 138 DEFINE_EVENT(spi_transfer, spi_transfer_start,
221 139
222 TP_PROTO(struct spi_message *msg, stru 140 TP_PROTO(struct spi_message *msg, struct spi_transfer *xfer),
223 141
224 TP_ARGS(msg, xfer) 142 TP_ARGS(msg, xfer)
225 143
226 ); 144 );
227 145
228 DEFINE_EVENT(spi_transfer, spi_transfer_stop, 146 DEFINE_EVENT(spi_transfer, spi_transfer_stop,
229 147
230 TP_PROTO(struct spi_message *msg, stru 148 TP_PROTO(struct spi_message *msg, struct spi_transfer *xfer),
231 149
232 TP_ARGS(msg, xfer) 150 TP_ARGS(msg, xfer)
233 151
234 ); 152 );
235 153
236 #endif /* _TRACE_POWER_H */ 154 #endif /* _TRACE_POWER_H */
237 155
238 /* This part must be outside protection */ 156 /* This part must be outside protection */
239 #include <trace/define_trace.h> 157 #include <trace/define_trace.h>
240 158
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.