Thomas Gleixner | dcc4086 | 2019-05-29 16:57:23 -0700 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
Taku Izumi | 82f6aea | 2016-10-14 20:27:38 +0900 | [diff] [blame] | 2 | /* |
| 3 | * FUJITSU Extended Socket Network Device driver |
| 4 | * Copyright (c) 2015-2016 FUJITSU LIMITED |
Taku Izumi | 82f6aea | 2016-10-14 20:27:38 +0900 | [diff] [blame] | 5 | */ |
| 6 | |
| 7 | #if !defined(FJES_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ) |
| 8 | #define FJES_TRACE_H_ |
| 9 | |
| 10 | #include <linux/types.h> |
| 11 | #include <linux/tracepoint.h> |
| 12 | |
| 13 | #undef TRACE_SYSTEM |
| 14 | #define TRACE_SYSTEM fjes |
| 15 | |
| 16 | /* tracepoints for fjes_hw.c */ |
| 17 | |
| 18 | TRACE_EVENT(fjes_hw_issue_request_command, |
| 19 | TP_PROTO(union REG_CR *cr, union REG_CS *cs, int timeout, |
| 20 | enum fjes_dev_command_response_e ret), |
| 21 | TP_ARGS(cr, cs, timeout, ret), |
| 22 | TP_STRUCT__entry( |
| 23 | __field(u16, cr_req) |
| 24 | __field(u8, cr_error) |
| 25 | __field(u16, cr_err_info) |
| 26 | __field(u8, cr_req_start) |
| 27 | __field(u16, cs_req) |
| 28 | __field(u8, cs_busy) |
| 29 | __field(u8, cs_complete) |
| 30 | __field(int, timeout) |
Peter Zijlstra | 04ae87a | 2019-10-24 22:26:59 +0200 | [diff] [blame] | 31 | __field(int, ret) |
Taku Izumi | 82f6aea | 2016-10-14 20:27:38 +0900 | [diff] [blame] | 32 | ), |
| 33 | TP_fast_assign( |
| 34 | __entry->cr_req = cr->bits.req_code; |
| 35 | __entry->cr_error = cr->bits.error; |
| 36 | __entry->cr_err_info = cr->bits.err_info; |
| 37 | __entry->cr_req_start = cr->bits.req_start; |
| 38 | __entry->cs_req = cs->bits.req_code; |
| 39 | __entry->cs_busy = cs->bits.busy; |
| 40 | __entry->cs_complete = cs->bits.complete; |
| 41 | __entry->timeout = timeout; |
| 42 | __entry->ret = ret; |
| 43 | ), |
| 44 | TP_printk("CR=[req=%04x, error=%u, err_info=%04x, req_start=%u], CS=[req=%04x, busy=%u, complete=%u], timeout=%d, ret=%d", |
| 45 | __entry->cr_req, __entry->cr_error, __entry->cr_err_info, |
| 46 | __entry->cr_req_start, __entry->cs_req, __entry->cs_busy, |
| 47 | __entry->cs_complete, __entry->timeout, __entry->ret) |
| 48 | ); |
| 49 | |
| 50 | TRACE_EVENT(fjes_hw_request_info, |
| 51 | TP_PROTO(struct fjes_hw *hw, union fjes_device_command_res *res_buf), |
| 52 | TP_ARGS(hw, res_buf), |
| 53 | TP_STRUCT__entry( |
| 54 | __field(int, length) |
| 55 | __field(int, code) |
| 56 | __dynamic_array(u8, zone, hw->max_epid) |
| 57 | __dynamic_array(u8, status, hw->max_epid) |
| 58 | ), |
| 59 | TP_fast_assign( |
| 60 | int x; |
| 61 | |
| 62 | __entry->length = res_buf->info.length; |
| 63 | __entry->code = res_buf->info.code; |
| 64 | for (x = 0; x < hw->max_epid; x++) { |
| 65 | *((u8 *)__get_dynamic_array(zone) + x) = |
| 66 | res_buf->info.info[x].zone; |
| 67 | *((u8 *)__get_dynamic_array(status) + x) = |
| 68 | res_buf->info.info[x].es_status; |
| 69 | } |
| 70 | ), |
| 71 | TP_printk("res_buf=[length=%d, code=%d, es_zones=%s, es_status=%s]", |
| 72 | __entry->length, __entry->code, |
| 73 | __print_array(__get_dynamic_array(zone), |
| 74 | __get_dynamic_array_len(zone) / sizeof(u8), |
| 75 | sizeof(u8)), |
| 76 | __print_array(__get_dynamic_array(status), |
| 77 | __get_dynamic_array_len(status) / sizeof(u8), |
| 78 | sizeof(u8))) |
| 79 | ); |
| 80 | |
| 81 | TRACE_EVENT(fjes_hw_request_info_err, |
| 82 | TP_PROTO(char *err), |
| 83 | TP_ARGS(err), |
| 84 | TP_STRUCT__entry( |
| 85 | __string(err, err) |
| 86 | ), |
| 87 | TP_fast_assign( |
Steven Rostedt (Google) | 2c92ca8 | 2024-05-16 13:34:54 -0400 | [diff] [blame] | 88 | __assign_str(err); |
Taku Izumi | 82f6aea | 2016-10-14 20:27:38 +0900 | [diff] [blame] | 89 | ), |
| 90 | TP_printk("%s", __get_str(err)) |
| 91 | ); |
| 92 | |
| 93 | TRACE_EVENT(fjes_hw_register_buff_addr_req, |
| 94 | TP_PROTO(union fjes_device_command_req *req_buf, |
| 95 | struct ep_share_mem_info *buf_pair), |
| 96 | TP_ARGS(req_buf, buf_pair), |
| 97 | TP_STRUCT__entry( |
| 98 | __field(int, length) |
| 99 | __field(int, epid) |
| 100 | __field(u64, tx) |
| 101 | __field(size_t, tx_size) |
| 102 | __field(u64, rx) |
| 103 | __field(size_t, rx_size) |
| 104 | ), |
| 105 | TP_fast_assign( |
| 106 | void *tx, *rx; |
| 107 | |
| 108 | tx = (void *)buf_pair->tx.buffer; |
| 109 | rx = (void *)buf_pair->rx.buffer; |
| 110 | __entry->length = req_buf->share_buffer.length; |
| 111 | __entry->epid = req_buf->share_buffer.epid; |
| 112 | __entry->tx_size = buf_pair->tx.size; |
| 113 | __entry->rx_size = buf_pair->rx.size; |
| 114 | __entry->tx = page_to_phys(vmalloc_to_page(tx)) + |
| 115 | offset_in_page(tx); |
| 116 | __entry->rx = page_to_phys(vmalloc_to_page(rx)) + |
| 117 | offset_in_page(rx); |
| 118 | ), |
| 119 | TP_printk("req_buf=[length=%d, epid=%d], TX=[phy=0x%016llx, size=%zu], RX=[phy=0x%016llx, size=%zu]", |
| 120 | __entry->length, __entry->epid, __entry->tx, __entry->tx_size, |
| 121 | __entry->rx, __entry->rx_size) |
| 122 | ); |
| 123 | |
| 124 | TRACE_EVENT(fjes_hw_register_buff_addr, |
| 125 | TP_PROTO(union fjes_device_command_res *res_buf, int timeout), |
| 126 | TP_ARGS(res_buf, timeout), |
| 127 | TP_STRUCT__entry( |
| 128 | __field(int, length) |
| 129 | __field(int, code) |
| 130 | __field(int, timeout) |
| 131 | ), |
| 132 | TP_fast_assign( |
| 133 | __entry->length = res_buf->share_buffer.length; |
| 134 | __entry->code = res_buf->share_buffer.code; |
| 135 | __entry->timeout = timeout; |
| 136 | ), |
| 137 | TP_printk("res_buf=[length=%d, code=%d], timeout=%d", |
| 138 | __entry->length, __entry->code, __entry->timeout) |
| 139 | ); |
| 140 | |
| 141 | TRACE_EVENT(fjes_hw_register_buff_addr_err, |
| 142 | TP_PROTO(char *err), |
| 143 | TP_ARGS(err), |
| 144 | TP_STRUCT__entry( |
| 145 | __string(err, err) |
| 146 | ), |
| 147 | TP_fast_assign( |
Steven Rostedt (Google) | 2c92ca8 | 2024-05-16 13:34:54 -0400 | [diff] [blame] | 148 | __assign_str(err); |
Taku Izumi | 82f6aea | 2016-10-14 20:27:38 +0900 | [diff] [blame] | 149 | ), |
| 150 | TP_printk("%s", __get_str(err)) |
| 151 | ); |
| 152 | |
| 153 | TRACE_EVENT(fjes_hw_unregister_buff_addr_req, |
| 154 | TP_PROTO(union fjes_device_command_req *req_buf), |
| 155 | TP_ARGS(req_buf), |
| 156 | TP_STRUCT__entry( |
| 157 | __field(int, length) |
| 158 | __field(int, epid) |
| 159 | ), |
| 160 | TP_fast_assign( |
| 161 | __entry->length = req_buf->unshare_buffer.length; |
| 162 | __entry->epid = req_buf->unshare_buffer.epid; |
| 163 | ), |
| 164 | TP_printk("req_buf=[length=%d, epid=%d]", |
| 165 | __entry->length, __entry->epid) |
| 166 | ); |
| 167 | |
| 168 | TRACE_EVENT(fjes_hw_unregister_buff_addr, |
| 169 | TP_PROTO(union fjes_device_command_res *res_buf, int timeout), |
| 170 | TP_ARGS(res_buf, timeout), |
| 171 | TP_STRUCT__entry( |
| 172 | __field(int, length) |
| 173 | __field(int, code) |
| 174 | __field(int, timeout) |
| 175 | ), |
| 176 | TP_fast_assign( |
| 177 | __entry->length = res_buf->unshare_buffer.length; |
| 178 | __entry->code = res_buf->unshare_buffer.code; |
| 179 | __entry->timeout = timeout; |
| 180 | ), |
| 181 | TP_printk("res_buf=[length=%d, code=%d], timeout=%d", |
| 182 | __entry->length, __entry->code, __entry->timeout) |
| 183 | ); |
| 184 | |
| 185 | TRACE_EVENT(fjes_hw_unregister_buff_addr_err, |
| 186 | TP_PROTO(char *err), |
| 187 | TP_ARGS(err), |
| 188 | TP_STRUCT__entry( |
| 189 | __string(err, err) |
| 190 | ), |
| 191 | TP_fast_assign( |
Steven Rostedt (Google) | 2c92ca8 | 2024-05-16 13:34:54 -0400 | [diff] [blame] | 192 | __assign_str(err); |
Taku Izumi | 82f6aea | 2016-10-14 20:27:38 +0900 | [diff] [blame] | 193 | ), |
| 194 | TP_printk("%s", __get_str(err)) |
| 195 | ); |
| 196 | |
Taku Izumi | b6ba737 | 2016-10-14 20:27:45 +0900 | [diff] [blame] | 197 | TRACE_EVENT(fjes_hw_start_debug_req, |
| 198 | TP_PROTO(union fjes_device_command_req *req_buf), |
| 199 | TP_ARGS(req_buf), |
| 200 | TP_STRUCT__entry( |
| 201 | __field(int, length) |
| 202 | __field(int, mode) |
| 203 | __field(phys_addr_t, buffer) |
| 204 | ), |
| 205 | TP_fast_assign( |
| 206 | __entry->length = req_buf->start_trace.length; |
| 207 | __entry->mode = req_buf->start_trace.mode; |
| 208 | __entry->buffer = req_buf->start_trace.buffer[0]; |
| 209 | ), |
Arnd Bergmann | ea93900 | 2016-10-17 16:30:57 +0200 | [diff] [blame] | 210 | TP_printk("req_buf=[length=%d, mode=%d, buffer=%pap]", |
| 211 | __entry->length, __entry->mode, &__entry->buffer) |
Taku Izumi | b6ba737 | 2016-10-14 20:27:45 +0900 | [diff] [blame] | 212 | ); |
| 213 | |
| 214 | TRACE_EVENT(fjes_hw_start_debug, |
| 215 | TP_PROTO(union fjes_device_command_res *res_buf), |
| 216 | TP_ARGS(res_buf), |
| 217 | TP_STRUCT__entry( |
| 218 | __field(int, length) |
| 219 | __field(int, code) |
| 220 | ), |
| 221 | TP_fast_assign( |
| 222 | __entry->length = res_buf->start_trace.length; |
| 223 | __entry->code = res_buf->start_trace.code; |
| 224 | ), |
| 225 | TP_printk("res_buf=[length=%d, code=%d]", __entry->length, __entry->code) |
| 226 | ); |
| 227 | |
| 228 | TRACE_EVENT(fjes_hw_start_debug_err, |
| 229 | TP_PROTO(char *err), |
| 230 | TP_ARGS(err), |
| 231 | TP_STRUCT__entry( |
| 232 | __string(err, err) |
| 233 | ), |
| 234 | TP_fast_assign( |
Steven Rostedt (Google) | 2c92ca8 | 2024-05-16 13:34:54 -0400 | [diff] [blame] | 235 | __assign_str(err); |
Taku Izumi | b6ba737 | 2016-10-14 20:27:45 +0900 | [diff] [blame] | 236 | ), |
| 237 | TP_printk("%s", __get_str(err)) |
| 238 | ); |
| 239 | |
| 240 | TRACE_EVENT(fjes_hw_stop_debug, |
| 241 | TP_PROTO(union fjes_device_command_res *res_buf), |
| 242 | TP_ARGS(res_buf), |
| 243 | TP_STRUCT__entry( |
| 244 | __field(int, length) |
| 245 | __field(int, code) |
| 246 | ), |
| 247 | TP_fast_assign( |
| 248 | __entry->length = res_buf->stop_trace.length; |
| 249 | __entry->code = res_buf->stop_trace.code; |
| 250 | ), |
| 251 | TP_printk("res_buf=[length=%d, code=%d]", __entry->length, __entry->code) |
| 252 | ); |
| 253 | |
| 254 | TRACE_EVENT(fjes_hw_stop_debug_err, |
| 255 | TP_PROTO(char *err), |
| 256 | TP_ARGS(err), |
| 257 | TP_STRUCT__entry( |
| 258 | __string(err, err) |
| 259 | ), |
| 260 | TP_fast_assign( |
Steven Rostedt (Google) | 2c92ca8 | 2024-05-16 13:34:54 -0400 | [diff] [blame] | 261 | __assign_str(err); |
Taku Izumi | b6ba737 | 2016-10-14 20:27:45 +0900 | [diff] [blame] | 262 | ), |
| 263 | TP_printk("%s", __get_str(err)) |
| 264 | ); |
| 265 | |
Taku Izumi | 82f6aea | 2016-10-14 20:27:38 +0900 | [diff] [blame] | 266 | /* tracepoints for fjes_main.c */ |
| 267 | |
| 268 | TRACE_EVENT(fjes_txrx_stop_req_irq_pre, |
| 269 | TP_PROTO(struct fjes_hw *hw, int src_epid, |
| 270 | enum ep_partner_status status), |
| 271 | TP_ARGS(hw, src_epid, status), |
| 272 | TP_STRUCT__entry( |
| 273 | __field(int, src_epid) |
| 274 | __field(enum ep_partner_status, status) |
| 275 | __field(u8, ep_status) |
| 276 | __field(unsigned long, txrx_stop_req_bit) |
| 277 | __field(u16, rx_status) |
| 278 | ), |
| 279 | TP_fast_assign( |
| 280 | __entry->src_epid = src_epid; |
| 281 | __entry->status = status; |
| 282 | __entry->ep_status = hw->hw_info.share->ep_status[src_epid]; |
| 283 | __entry->txrx_stop_req_bit = hw->txrx_stop_req_bit; |
| 284 | __entry->rx_status = |
| 285 | hw->ep_shm_info[src_epid].tx.info->v1i.rx_status; |
| 286 | ), |
| 287 | TP_printk("epid=%d, partner_status=%d, ep_status=%x, txrx_stop_req_bit=%016lx, tx.rx_status=%08x", |
| 288 | __entry->src_epid, __entry->status, __entry->ep_status, |
| 289 | __entry->txrx_stop_req_bit, __entry->rx_status) |
| 290 | ); |
| 291 | |
| 292 | TRACE_EVENT(fjes_txrx_stop_req_irq_post, |
| 293 | TP_PROTO(struct fjes_hw *hw, int src_epid), |
| 294 | TP_ARGS(hw, src_epid), |
| 295 | TP_STRUCT__entry( |
| 296 | __field(int, src_epid) |
| 297 | __field(u8, ep_status) |
| 298 | __field(unsigned long, txrx_stop_req_bit) |
| 299 | __field(u16, rx_status) |
| 300 | ), |
| 301 | TP_fast_assign( |
| 302 | __entry->src_epid = src_epid; |
| 303 | __entry->ep_status = hw->hw_info.share->ep_status[src_epid]; |
| 304 | __entry->txrx_stop_req_bit = hw->txrx_stop_req_bit; |
| 305 | __entry->rx_status = hw->ep_shm_info[src_epid].tx.info->v1i.rx_status; |
| 306 | ), |
| 307 | TP_printk("epid=%d, ep_status=%x, txrx_stop_req_bit=%016lx, tx.rx_status=%08x", |
| 308 | __entry->src_epid, __entry->ep_status, |
| 309 | __entry->txrx_stop_req_bit, __entry->rx_status) |
| 310 | ); |
| 311 | |
| 312 | TRACE_EVENT(fjes_stop_req_irq_pre, |
| 313 | TP_PROTO(struct fjes_hw *hw, int src_epid, |
| 314 | enum ep_partner_status status), |
| 315 | TP_ARGS(hw, src_epid, status), |
| 316 | TP_STRUCT__entry( |
| 317 | __field(int, src_epid) |
| 318 | __field(enum ep_partner_status, status) |
| 319 | __field(u8, ep_status) |
| 320 | __field(unsigned long, txrx_stop_req_bit) |
| 321 | __field(u16, rx_status) |
| 322 | ), |
| 323 | TP_fast_assign( |
| 324 | __entry->src_epid = src_epid; |
| 325 | __entry->status = status; |
| 326 | __entry->ep_status = hw->hw_info.share->ep_status[src_epid]; |
| 327 | __entry->txrx_stop_req_bit = hw->txrx_stop_req_bit; |
| 328 | __entry->rx_status = |
| 329 | hw->ep_shm_info[src_epid].tx.info->v1i.rx_status; |
| 330 | ), |
| 331 | TP_printk("epid=%d, partner_status=%d, ep_status=%x, txrx_stop_req_bit=%016lx, tx.rx_status=%08x", |
| 332 | __entry->src_epid, __entry->status, __entry->ep_status, |
| 333 | __entry->txrx_stop_req_bit, __entry->rx_status) |
| 334 | ); |
| 335 | |
| 336 | TRACE_EVENT(fjes_stop_req_irq_post, |
| 337 | TP_PROTO(struct fjes_hw *hw, int src_epid), |
| 338 | TP_ARGS(hw, src_epid), |
| 339 | TP_STRUCT__entry( |
| 340 | __field(int, src_epid) |
| 341 | __field(u8, ep_status) |
| 342 | __field(unsigned long, txrx_stop_req_bit) |
| 343 | __field(u16, rx_status) |
| 344 | ), |
| 345 | TP_fast_assign( |
| 346 | __entry->src_epid = src_epid; |
| 347 | __entry->ep_status = hw->hw_info.share->ep_status[src_epid]; |
| 348 | __entry->txrx_stop_req_bit = hw->txrx_stop_req_bit; |
| 349 | __entry->rx_status = |
| 350 | hw->ep_shm_info[src_epid].tx.info->v1i.rx_status; |
| 351 | ), |
| 352 | TP_printk("epid=%d, ep_status=%x, txrx_stop_req_bit=%016lx, tx.rx_status=%08x", |
| 353 | __entry->src_epid, __entry->ep_status, |
| 354 | __entry->txrx_stop_req_bit, __entry->rx_status) |
| 355 | ); |
| 356 | |
| 357 | #endif /* FJES_TRACE_H_ */ |
| 358 | |
| 359 | #undef TRACE_INCLUDE_PATH |
| 360 | #undef TRACE_INCLUDE_FILE |
Jakub Kicinski | 57e3c5a | 2024-05-28 19:33:22 -0700 | [diff] [blame] | 361 | #define TRACE_INCLUDE_PATH ../../drivers/net/fjes |
Taku Izumi | 82f6aea | 2016-10-14 20:27:38 +0900 | [diff] [blame] | 362 | #define TRACE_INCLUDE_FILE fjes_trace |
| 363 | |
| 364 | /* This part must be outside protection */ |
| 365 | #include <trace/define_trace.h> |