1 /*- 2 * Copyright (c) 2017 Chelsio Communications, Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 * 28 */ 29 30 /* 31 * Chelsio Unified Debug Interface header file. 32 * Version 1.1 33 */ 34 #ifndef _CUDBG_IF_H_ 35 #define _CUDBG_IF_H_ 36 37 #ifdef __GNUC__ 38 #define ATTRIBUTE_UNUSED __attribute__ ((unused)) 39 #else 40 #define ATTRIBUTE_UNUSED 41 #endif 42 43 #if defined(CONFIG_CUDBG_DEBUG) 44 #define cudbg_debug(pdbg_init, format, ...) do {\ 45 pdbg_init->print(format, ##__VA_ARGS__); \ 46 } while (0) 47 #else 48 #define cudbg_debug(pdbg_init, format, ...) do { } while (0) 49 #endif 50 51 #define OUT 52 #define IN 53 #define INOUT 54 55 /* Error codes */ 56 57 #define CUDBG_STATUS_SUCCESS 0 58 #define CUDBG_STATUS_NOSPACE -2 59 #define CUDBG_STATUS_FLASH_WRITE_FAIL -3 60 #define CUDBG_STATUS_FLASH_READ_FAIL -4 61 #define CUDBG_STATUS_UNDEFINED_OUT_BUF -5 62 #define CUDBG_STATUS_UNDEFINED_CBFN -6 63 #define CUDBG_STATUS_UNDEFINED_PRINTF_CBFN -7 64 #define CUDBG_STATUS_ADAP_INVALID -8 65 #define CUDBG_STATUS_FLASH_EMPTY -9 66 #define CUDBG_STATUS_NO_ADAPTER -10 67 #define CUDBG_STATUS_NO_SIGNATURE -11 68 #define CUDBG_STATUS_MULTIPLE_REG -12 69 #define CUDBG_STATUS_UNREGISTERED -13 70 #define CUDBG_STATUS_UNDEFINED_ENTITY -14 71 #define CUDBG_STATUS_REG_FAIlED -15 72 #define CUDBG_STATUS_DEVLOG_FAILED -16 73 #define CUDBG_STATUS_SMALL_BUFF -17 74 #define CUDBG_STATUS_CHKSUM_MISSMATCH -18 75 #define CUDBG_STATUS_NO_SCRATCH_MEM -19 76 #define CUDBG_STATUS_OUTBUFF_OVERFLOW -20 77 #define CUDBG_STATUS_INVALID_BUFF -21 /* Invalid magic */ 78 #define CUDBG_STATUS_FILE_OPEN_FAIL -22 79 #define CUDBG_STATUS_DEVLOG_INT_FAIL -23 80 #define CUDBG_STATUS_ENTITY_NOT_FOUND -24 81 #define CUDBG_STATUS_DECOMPRESS_FAIL -25 82 #define CUDBG_STATUS_BUFFER_SHORT -26 83 #define CUDBG_METADATA_VERSION_MISMATCH -27 84 #define CUDBG_STATUS_NOT_IMPLEMENTED -28 85 #define CUDBG_SYSTEM_ERROR -29 86 #define CUDBG_STATUS_MMAP_FAILED -30 87 #define CUDBG_STATUS_FILE_WRITE_FAILED -31 88 #define CUDBG_STATUS_CCLK_NOT_DEFINED -32 89 #define CUDBG_STATUS_FLASH_FULL -33 90 #define CUDBG_STATUS_SECTOR_EMPTY -34 91 #define CUDBG_STATUS_ENTITY_NOT_REQUESTED -35 92 #define CUDBG_STATUS_NOT_SUPPORTED -36 93 #define CUDBG_STATUS_FILE_READ_FAILED -37 94 #define CUDBG_STATUS_CORRUPTED -38 95 #define CUDBG_STATUS_INVALID_INDEX -39 96 97 #define CUDBG_MAJOR_VERSION 1 98 #define CUDBG_MINOR_VERSION 14 99 #define CUDBG_BUILD_VERSION 0 100 101 #define CUDBG_FILE_NAME_LEN 256 102 #define CUDBG_DIR_NAME_LEN 256 103 #define CUDBG_MAX_BITMAP_LEN 16 104 105 static char ATTRIBUTE_UNUSED * err_msg[] = { 106 "Success", 107 "Unknown", 108 "No space", 109 "Flash write fail", 110 "Flash read fail", 111 "Undefined out buf", 112 "Callback function undefined", 113 "Print callback function undefined", 114 "ADAP invalid", 115 "Flash empty", 116 "No adapter", 117 "No signature", 118 "Multiple registration", 119 "Unregistered", 120 "Undefined entity", 121 "Reg failed", 122 "Devlog failed", 123 "Small buff", 124 "Checksum mismatch", 125 "No scratch memory", 126 "Outbuff overflow", 127 "Invalid buffer", 128 "File open fail", 129 "Devlog int fail", 130 "Entity not found", 131 "Decompress fail", 132 "Buffer short", 133 "Version mismatch", 134 "Not implemented", 135 "System error", 136 "Mmap failed", 137 "File write failed", 138 "cclk not defined", 139 "Flash full", 140 "Sector empty", 141 "Entity not requested", 142 "Not supported", 143 "File read fail", 144 "Corrupted", 145 "Invalid Index" 146 }; 147 148 enum CUDBG_DBG_ENTITY_TYPE { 149 CUDBG_ALL = 0, 150 CUDBG_REG_DUMP = 1, 151 CUDBG_DEV_LOG = 2, 152 CUDBG_CIM_LA = 3, 153 CUDBG_CIM_MA_LA = 4, 154 CUDBG_CIM_QCFG = 5, 155 CUDBG_CIM_IBQ_TP0 = 6, 156 CUDBG_CIM_IBQ_TP1 = 7, 157 CUDBG_CIM_IBQ_ULP = 8, 158 CUDBG_CIM_IBQ_SGE0 = 9, 159 CUDBG_CIM_IBQ_SGE1 = 10, 160 CUDBG_CIM_IBQ_NCSI = 11, 161 CUDBG_CIM_OBQ_ULP0 = 12, 162 CUDBG_CIM_OBQ_ULP1 = 13, 163 CUDBG_CIM_OBQ_ULP2 = 14, 164 CUDBG_CIM_OBQ_ULP3 = 15, 165 CUDBG_CIM_OBQ_SGE = 16, 166 CUDBG_CIM_OBQ_NCSI = 17, 167 CUDBG_EDC0 = 18, 168 CUDBG_EDC1 = 19, 169 CUDBG_MC0 = 20, 170 CUDBG_MC1 = 21, 171 CUDBG_RSS = 22, 172 CUDBG_RSS_PF_CONF = 23, 173 CUDBG_RSS_KEY = 24, 174 CUDBG_RSS_VF_CONF = 25, 175 CUDBG_RSS_CONF = 26, 176 CUDBG_PATH_MTU = 27, 177 CUDBG_SW_STATE = 28, 178 CUDBG_WTP = 29, 179 CUDBG_PM_STATS = 30, 180 CUDBG_HW_SCHED = 31, 181 CUDBG_TCP_STATS = 32, 182 CUDBG_TP_ERR_STATS = 33, 183 CUDBG_FCOE_STATS = 34, 184 CUDBG_RDMA_STATS = 35, 185 CUDBG_TP_INDIRECT = 36, 186 CUDBG_SGE_INDIRECT = 37, 187 CUDBG_CPL_STATS = 38, 188 CUDBG_DDP_STATS = 39, 189 CUDBG_WC_STATS = 40, 190 CUDBG_ULPRX_LA = 41, 191 CUDBG_LB_STATS = 42, 192 CUDBG_TP_LA = 43, 193 CUDBG_MEMINFO = 44, 194 CUDBG_CIM_PIF_LA = 45, 195 CUDBG_CLK = 46, 196 CUDBG_CIM_OBQ_RXQ0 = 47, 197 CUDBG_CIM_OBQ_RXQ1 = 48, 198 CUDBG_MAC_STATS = 49, 199 CUDBG_PCIE_INDIRECT = 50, 200 CUDBG_PM_INDIRECT = 51, 201 CUDBG_FULL = 52, 202 CUDBG_TX_RATE = 53, 203 CUDBG_TID_INFO = 54, 204 CUDBG_PCIE_CONFIG = 55, 205 CUDBG_DUMP_CONTEXT = 56, 206 CUDBG_MPS_TCAM = 57, 207 CUDBG_VPD_DATA = 58, 208 CUDBG_LE_TCAM = 59, 209 CUDBG_CCTRL = 60, 210 CUDBG_MA_INDIRECT = 61, 211 CUDBG_ULPTX_LA = 62, 212 CUDBG_EXT_ENTITY = 63, 213 CUDBG_UP_CIM_INDIRECT = 64, 214 CUDBG_PBT_TABLE = 65, 215 CUDBG_MBOX_LOG = 66, 216 CUDBG_HMA_INDIRECT = 67, 217 CUDBG_MAX_ENTITY = 68, 218 }; 219 220 #define ENTITY_FLAG_NULL 0 221 #define ENTITY_FLAG_REGISTER 1 222 #define ENTITY_FLAG_BINARY 2 223 #define ENTITY_FLAG_FW_NO_ATTACH 3 224 225 /* file_name matches Linux cxgb4 debugfs entry names. */ 226 struct el {char *name; char *file_name; int bit; u32 flag; }; 227 static struct el ATTRIBUTE_UNUSED entity_list[] = { 228 {"all", "all", CUDBG_ALL, ENTITY_FLAG_NULL}, 229 {"regdump", "regdump", CUDBG_REG_DUMP, 1 << ENTITY_FLAG_REGISTER}, 230 /* {"reg", CUDBG_REG_DUMP},*/ 231 {"devlog", "devlog", CUDBG_DEV_LOG, ENTITY_FLAG_NULL}, 232 {"cimla", "cim_la", CUDBG_CIM_LA, ENTITY_FLAG_NULL}, 233 {"cimmala", "cim_ma_la", CUDBG_CIM_MA_LA, ENTITY_FLAG_NULL}, 234 {"cimqcfg", "cim_qcfg", CUDBG_CIM_QCFG, ENTITY_FLAG_NULL}, 235 {"ibqtp0", "ibq_tp0", CUDBG_CIM_IBQ_TP0, ENTITY_FLAG_NULL}, 236 {"ibqtp1", "ibq_tp1", CUDBG_CIM_IBQ_TP1, ENTITY_FLAG_NULL}, 237 {"ibqulp", "ibq_ulp", CUDBG_CIM_IBQ_ULP, ENTITY_FLAG_NULL}, 238 {"ibqsge0", "ibq_sge0", CUDBG_CIM_IBQ_SGE0, ENTITY_FLAG_NULL}, 239 {"ibqsge1", "ibq_sge1", CUDBG_CIM_IBQ_SGE1, ENTITY_FLAG_NULL}, 240 {"ibqncsi", "ibq_ncsi", CUDBG_CIM_IBQ_NCSI, ENTITY_FLAG_NULL}, 241 {"obqulp0", "obq_ulp0", CUDBG_CIM_OBQ_ULP0, ENTITY_FLAG_NULL}, 242 /* {"cimobqulp1", CUDBG_CIM_OBQ_ULP1},*/ 243 {"obqulp1", "obq_ulp1", CUDBG_CIM_OBQ_ULP1, ENTITY_FLAG_NULL}, 244 {"obqulp2", "obq_ulp2", CUDBG_CIM_OBQ_ULP2, ENTITY_FLAG_NULL}, 245 {"obqulp3", "obq_ulp3", CUDBG_CIM_OBQ_ULP3, ENTITY_FLAG_NULL}, 246 {"obqsge", "obq_sge", CUDBG_CIM_OBQ_SGE, ENTITY_FLAG_NULL}, 247 {"obqncsi", "obq_ncsi", CUDBG_CIM_OBQ_NCSI, ENTITY_FLAG_NULL}, 248 {"edc0", "edc0", CUDBG_EDC0, (1 << ENTITY_FLAG_BINARY)}, 249 {"edc1", "edc1", CUDBG_EDC1, (1 << ENTITY_FLAG_BINARY)}, 250 {"mc0", "mc0", CUDBG_MC0, (1 << ENTITY_FLAG_BINARY)}, 251 {"mc1", "mc1", CUDBG_MC1, (1 << ENTITY_FLAG_BINARY)}, 252 {"rss", "rss", CUDBG_RSS, ENTITY_FLAG_NULL}, 253 {"rss_pf_config", "rss_pf_config", CUDBG_RSS_PF_CONF, ENTITY_FLAG_NULL}, 254 {"rss_key", "rss_key", CUDBG_RSS_KEY, ENTITY_FLAG_NULL}, 255 {"rss_vf_config", "rss_vf_config", CUDBG_RSS_VF_CONF, ENTITY_FLAG_NULL}, 256 {"rss_config", "rss_config", CUDBG_RSS_CONF, ENTITY_FLAG_NULL}, 257 {"pathmtu", "path_mtus", CUDBG_PATH_MTU, ENTITY_FLAG_NULL}, 258 {"swstate", "sw_state", CUDBG_SW_STATE, ENTITY_FLAG_NULL}, 259 {"wtp", "wtp", CUDBG_WTP, ENTITY_FLAG_NULL}, 260 {"pmstats", "pm_stats", CUDBG_PM_STATS, ENTITY_FLAG_NULL}, 261 {"hwsched", "hw_sched", CUDBG_HW_SCHED, ENTITY_FLAG_NULL}, 262 {"tcpstats", "tcp_stats", CUDBG_TCP_STATS, ENTITY_FLAG_NULL}, 263 {"tperrstats", "tp_err_stats", CUDBG_TP_ERR_STATS, ENTITY_FLAG_NULL}, 264 {"fcoestats", "fcoe_stats", CUDBG_FCOE_STATS, ENTITY_FLAG_NULL}, 265 {"rdmastats", "rdma_stats", CUDBG_RDMA_STATS, ENTITY_FLAG_NULL}, 266 {"tpindirect", "tp_indirect", CUDBG_TP_INDIRECT, 267 1 << ENTITY_FLAG_REGISTER}, 268 {"sgeindirect", "sge_indirect", CUDBG_SGE_INDIRECT, 269 1 << ENTITY_FLAG_REGISTER}, 270 {"cplstats", "cpl_stats", CUDBG_CPL_STATS, ENTITY_FLAG_NULL}, 271 {"ddpstats", "ddp_stats", CUDBG_DDP_STATS, ENTITY_FLAG_NULL}, 272 {"wcstats", "wc_stats", CUDBG_WC_STATS, ENTITY_FLAG_NULL}, 273 {"ulprxla", "ulprx_la", CUDBG_ULPRX_LA, ENTITY_FLAG_NULL}, 274 {"lbstats", "lb_stats", CUDBG_LB_STATS, ENTITY_FLAG_NULL}, 275 {"tpla", "tp_la", CUDBG_TP_LA, ENTITY_FLAG_NULL}, 276 {"meminfo", "meminfo", CUDBG_MEMINFO, ENTITY_FLAG_NULL}, 277 {"cimpifla", "cim_pif_la", CUDBG_CIM_PIF_LA, ENTITY_FLAG_NULL}, 278 {"clk", "clk", CUDBG_CLK, ENTITY_FLAG_NULL}, 279 {"obq_sge_rx_q0", "obq_sge_rx_q0", CUDBG_CIM_OBQ_RXQ0, 280 ENTITY_FLAG_NULL}, 281 {"obq_sge_rx_q1", "obq_sge_rx_q1", CUDBG_CIM_OBQ_RXQ1, 282 ENTITY_FLAG_NULL}, 283 {"macstats", "mac_stats", CUDBG_MAC_STATS, ENTITY_FLAG_NULL}, 284 {"pcieindirect", "pcie_indirect", CUDBG_PCIE_INDIRECT, 285 1 << ENTITY_FLAG_REGISTER}, 286 {"pmindirect", "pm_indirect", CUDBG_PM_INDIRECT, 287 1 << ENTITY_FLAG_REGISTER}, 288 {"full", "full", CUDBG_FULL, ENTITY_FLAG_NULL}, 289 {"txrate", "tx_rate", CUDBG_TX_RATE, ENTITY_FLAG_NULL}, 290 {"tidinfo", "tids", CUDBG_TID_INFO, ENTITY_FLAG_NULL | 291 (1 << ENTITY_FLAG_FW_NO_ATTACH)}, 292 {"pcieconfig", "pcie_config", CUDBG_PCIE_CONFIG, ENTITY_FLAG_NULL}, 293 {"dumpcontext", "dump_context", CUDBG_DUMP_CONTEXT, ENTITY_FLAG_NULL}, 294 {"mpstcam", "mps_tcam", CUDBG_MPS_TCAM, ENTITY_FLAG_NULL}, 295 {"vpddata", "vpd_data", CUDBG_VPD_DATA, ENTITY_FLAG_NULL}, 296 {"letcam", "le_tcam", CUDBG_LE_TCAM, ENTITY_FLAG_NULL}, 297 {"cctrl", "cctrl", CUDBG_CCTRL, ENTITY_FLAG_NULL}, 298 {"maindirect", "ma_indirect", CUDBG_MA_INDIRECT, 299 1 << ENTITY_FLAG_REGISTER}, 300 {"ulptxla", "ulptx_la", CUDBG_ULPTX_LA, ENTITY_FLAG_NULL}, 301 {"extentity", "ext_entity", CUDBG_EXT_ENTITY, ENTITY_FLAG_NULL}, 302 {"upcimindirect", "up_cim_indirect", CUDBG_UP_CIM_INDIRECT, 303 1 << ENTITY_FLAG_REGISTER}, 304 {"pbttables", "pbt_tables", CUDBG_PBT_TABLE, ENTITY_FLAG_NULL}, 305 {"mboxlog", "mboxlog", CUDBG_MBOX_LOG, ENTITY_FLAG_NULL}, 306 {"hmaindirect", "hma_indirect", CUDBG_HMA_INDIRECT, 307 1 << ENTITY_FLAG_REGISTER}, 308 }; 309 310 typedef int (*cudbg_print_cb) (char *str, ...); 311 312 struct cudbg_init_hdr { 313 u8 major_ver; 314 u8 minor_ver; 315 u8 build_ver; 316 u8 res; 317 u16 init_struct_size; 318 }; 319 320 struct cudbg_flash_hdr { 321 u32 signature; 322 u8 major_ver; 323 u8 minor_ver; 324 u8 build_ver; 325 u8 res; 326 u64 timestamp; 327 u64 time_res; 328 u32 hdr_len; 329 u32 data_len; 330 u32 hdr_flags; 331 u32 sec_seq_no; 332 u32 reserved[22]; 333 }; 334 335 struct cudbg_param { 336 u16 param_type; 337 u16 reserved; 338 union { 339 struct { 340 u32 memtype; /* which memory (EDC0, EDC1, MC) */ 341 u32 start; /* start of log in firmware memory */ 342 u32 size; /* size of log */ 343 } devlog_param; 344 struct { 345 struct mbox_cmd_log *log; 346 u16 mbox_cmds; 347 } mboxlog_param; 348 struct { 349 u8 caller_string[100]; 350 u8 os_type; 351 } sw_state_param; 352 u64 time; 353 u8 tcb_bit_param; 354 void *adap; 355 void *access_lock; 356 } u; 357 }; 358 359 /* params for tcb_bit_param */ 360 #define CUDBG_TCB_BRIEF_PARAM 0x1 361 #define CUDBG_TCB_FROM_CARD_PARAM 0x2 362 #define CUDBG_TCB_AS_SCB_PARAM 0x4 363 364 /* 365 * * What is OFFLINE_VIEW_ONLY mode? 366 * 367 * cudbg frame work will be used only to interpret previously collected 368 * data store in a file (i.e NOT hw flash) 369 */ 370 371 struct cudbg_init { 372 struct cudbg_init_hdr header; 373 struct adapter *adap; /* Pointer to adapter structure 374 with filled fields */ 375 cudbg_print_cb print; /* Platform dependent print 376 function */ 377 u32 verbose:1; /* Turn on verbose print */ 378 u32 use_flash:1; /* Use flash to collect or view 379 debug */ 380 u32 full_mode:1; /* If set, cudbg will pull in 381 common code */ 382 u32 no_compress:1; /* Dont compress will storing 383 the collected debug */ 384 u32 info:1; /* Show just the info, Dont 385 interpret */ 386 u32 reserved:27; 387 u8 dbg_bitmap[CUDBG_MAX_BITMAP_LEN]; 388 /* Bit map to select the dbg 389 data type to be collected 390 or viewed */ 391 }; 392 393 394 /********************************* Helper functions *************************/ 395 static inline void set_dbg_bitmap(u8 *bitmap, enum CUDBG_DBG_ENTITY_TYPE type) 396 { 397 int index = type / 8; 398 int bit = type % 8; 399 400 bitmap[index] |= (1 << bit); 401 } 402 403 static inline void reset_dbg_bitmap(u8 *bitmap, enum CUDBG_DBG_ENTITY_TYPE type) 404 { 405 int index = type / 8; 406 int bit = type % 8; 407 408 bitmap[index] &= ~(1 << bit); 409 } 410 411 /********************************* End of Helper functions 412 * *************************/ 413 414 /* API Prototypes */ 415 416 /** 417 * cudbg_alloc_handle - Allocates and initializes a handle that represents 418 * cudbg state. Needs to called first before calling any other function. 419 * 420 * returns a pointer to memory that has a cudbg_init structure at the beginning 421 * and enough space after that for internal book keeping. 422 */ 423 424 void *cudbg_alloc_handle(void); 425 static inline struct cudbg_init *cudbg_get_init(void *handle) 426 { 427 return (handle); 428 } 429 430 /** 431 * cudbg_collect - Collect and store debug information. 432 * ## Parameters ## 433 * @handle : A pointer returned by cudbg_alloc_handle. 434 * @outbuf : pointer to output buffer, to store the collected information 435 * or to use it as a scratch buffer in case HW flash is used to 436 * store the debug information. 437 * @outbuf_size : Size of output buffer. 438 * ## Return ## 439 * If the function succeeds, the return value will be size of debug information 440 * collected and stored. 441 * -ve value represent error. 442 */ 443 int cudbg_collect(void *handle, void *outbuf, u32 *outbuf_size); 444 445 /** 446 * cudbg_free_handle - Release cudbg resources. 447 * ## Parameters ## 448 * @handle : A pointer returned by cudbg_alloc_handle. 449 */ 450 451 void cudbg_free_handle(IN void *handle); 452 453 /** 454 * cudbg_read_flash_data - Read cudbg “flash” header from adapter flash. 455 * This will be used by the consumer mainly to 456 * know the size of the data in flash. 457 * ## Parameters ## 458 * @handle : A pointer returned by cudbg_hello. 459 * @data : A pointer to data/header buffer 460 */ 461 462 int cudbg_read_flash_details(void *handle, struct cudbg_flash_hdr *data); 463 464 /** 465 * cudbg_read_flash_data - Read cudbg dump contents stored in flash. 466 * ## Parameters ## 467 * @handle : A pointer returned by cudbg_hello. 468 * @data_buf : A pointer to data buffer. 469 * @data_buf_size : Data buffer size. 470 */ 471 472 int cudbg_read_flash_data(void *handle, void *data_buf, u32 data_buf_size); 473 474 #endif /* _CUDBG_IF_H_ */ 475