]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * ipmi_kcs_sm.c | |
3 | * | |
4 | * State machine for handling IPMI KCS interfaces. | |
5 | * | |
6 | * Author: MontaVista Software, Inc. | |
7 | * Corey Minyard <minyard@mvista.com> | |
8 | * source@mvista.com | |
9 | * | |
10 | * Copyright 2002 MontaVista Software Inc. | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or modify it | |
13 | * under the terms of the GNU General Public License as published by the | |
14 | * Free Software Foundation; either version 2 of the License, or (at your | |
15 | * option) any later version. | |
16 | * | |
17 | * | |
18 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED | |
19 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
20 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |
21 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | |
22 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, | |
23 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS | |
24 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
25 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR | |
26 | * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE | |
27 | * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
28 | * | |
29 | * You should have received a copy of the GNU General Public License along | |
30 | * with this program; if not, write to the Free Software Foundation, Inc., | |
31 | * 675 Mass Ave, Cambridge, MA 02139, USA. | |
32 | */ | |
33 | ||
34 | /* | |
35 | * This state machine is taken from the state machine in the IPMI spec, | |
36 | * pretty much verbatim. If you have questions about the states, see | |
37 | * that document. | |
38 | */ | |
39 | ||
40 | #include <linux/kernel.h> /* For printk. */ | |
c4edff1c CM |
41 | #include <linux/module.h> |
42 | #include <linux/moduleparam.h> | |
1da177e4 | 43 | #include <linux/string.h> |
c3e7e791 | 44 | #include <linux/jiffies.h> |
1da177e4 LT |
45 | #include <linux/ipmi_msgdefs.h> /* for completion codes */ |
46 | #include "ipmi_si_sm.h" | |
47 | ||
c4edff1c CM |
48 | /* kcs_debug is a bit-field |
49 | * KCS_DEBUG_ENABLE - turned on for now | |
50 | * KCS_DEBUG_MSG - commands and their responses | |
51 | * KCS_DEBUG_STATES - state machine | |
52 | */ | |
53 | #define KCS_DEBUG_STATES 4 | |
54 | #define KCS_DEBUG_MSG 2 | |
55 | #define KCS_DEBUG_ENABLE 1 | |
1da177e4 | 56 | |
c4edff1c CM |
57 | static int kcs_debug; |
58 | module_param(kcs_debug, int, 0644); | |
59 | MODULE_PARM_DESC(kcs_debug, "debug bitmask, 1=enable, 2=messages, 4=states"); | |
1da177e4 LT |
60 | |
61 | /* The states the KCS driver may be in. */ | |
62 | enum kcs_states { | |
c305e3d3 CM |
63 | /* The KCS interface is currently doing nothing. */ |
64 | KCS_IDLE, | |
65 | ||
66 | /* | |
67 | * We are starting an operation. The data is in the output | |
68 | * buffer, but nothing has been done to the interface yet. This | |
69 | * was added to the state machine in the spec to wait for the | |
70 | * initial IBF. | |
71 | */ | |
72 | KCS_START_OP, | |
73 | ||
74 | /* We have written a write cmd to the interface. */ | |
75 | KCS_WAIT_WRITE_START, | |
76 | ||
77 | /* We are writing bytes to the interface. */ | |
78 | KCS_WAIT_WRITE, | |
79 | ||
80 | /* | |
81 | * We have written the write end cmd to the interface, and | |
82 | * still need to write the last byte. | |
83 | */ | |
84 | KCS_WAIT_WRITE_END, | |
85 | ||
86 | /* We are waiting to read data from the interface. */ | |
87 | KCS_WAIT_READ, | |
88 | ||
89 | /* | |
90 | * State to transition to the error handler, this was added to | |
91 | * the state machine in the spec to be sure IBF was there. | |
92 | */ | |
93 | KCS_ERROR0, | |
94 | ||
95 | /* | |
96 | * First stage error handler, wait for the interface to | |
97 | * respond. | |
98 | */ | |
99 | KCS_ERROR1, | |
100 | ||
101 | /* | |
102 | * The abort cmd has been written, wait for the interface to | |
103 | * respond. | |
104 | */ | |
105 | KCS_ERROR2, | |
106 | ||
107 | /* | |
108 | * We wrote some data to the interface, wait for it to switch | |
109 | * to read mode. | |
110 | */ | |
111 | KCS_ERROR3, | |
112 | ||
113 | /* The hardware failed to follow the state machine. */ | |
114 | KCS_HOSED | |
1da177e4 LT |
115 | }; |
116 | ||
5a1099ba CM |
117 | #define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH |
118 | #define MAX_KCS_WRITE_SIZE IPMI_MAX_MSG_LENGTH | |
1da177e4 LT |
119 | |
120 | /* Timeouts in microseconds. */ | |
ccb3368c XX |
121 | #define IBF_RETRY_TIMEOUT (5*USEC_PER_SEC) |
122 | #define OBF_RETRY_TIMEOUT (5*USEC_PER_SEC) | |
1da177e4 | 123 | #define MAX_ERROR_RETRIES 10 |
c3e7e791 | 124 | #define ERROR0_OBF_WAIT_JIFFIES (2*HZ) |
1da177e4 | 125 | |
c305e3d3 | 126 | struct si_sm_data { |
1da177e4 LT |
127 | enum kcs_states state; |
128 | struct si_sm_io *io; | |
129 | unsigned char write_data[MAX_KCS_WRITE_SIZE]; | |
130 | int write_pos; | |
131 | int write_count; | |
132 | int orig_write_count; | |
133 | unsigned char read_data[MAX_KCS_READ_SIZE]; | |
134 | int read_pos; | |
135 | int truncated; | |
136 | ||
137 | unsigned int error_retries; | |
138 | long ibf_timeout; | |
139 | long obf_timeout; | |
c3e7e791 | 140 | unsigned long error0_timeout; |
1da177e4 LT |
141 | }; |
142 | ||
143 | static unsigned int init_kcs_data(struct si_sm_data *kcs, | |
144 | struct si_sm_io *io) | |
145 | { | |
146 | kcs->state = KCS_IDLE; | |
147 | kcs->io = io; | |
148 | kcs->write_pos = 0; | |
149 | kcs->write_count = 0; | |
150 | kcs->orig_write_count = 0; | |
151 | kcs->read_pos = 0; | |
152 | kcs->error_retries = 0; | |
153 | kcs->truncated = 0; | |
154 | kcs->ibf_timeout = IBF_RETRY_TIMEOUT; | |
155 | kcs->obf_timeout = OBF_RETRY_TIMEOUT; | |
156 | ||
157 | /* Reserve 2 I/O bytes. */ | |
158 | return 2; | |
159 | } | |
160 | ||
161 | static inline unsigned char read_status(struct si_sm_data *kcs) | |
162 | { | |
163 | return kcs->io->inputb(kcs->io, 1); | |
164 | } | |
165 | ||
166 | static inline unsigned char read_data(struct si_sm_data *kcs) | |
167 | { | |
168 | return kcs->io->inputb(kcs->io, 0); | |
169 | } | |
170 | ||
171 | static inline void write_cmd(struct si_sm_data *kcs, unsigned char data) | |
172 | { | |
173 | kcs->io->outputb(kcs->io, 1, data); | |
174 | } | |
175 | ||
176 | static inline void write_data(struct si_sm_data *kcs, unsigned char data) | |
177 | { | |
178 | kcs->io->outputb(kcs->io, 0, data); | |
179 | } | |
180 | ||
181 | /* Control codes. */ | |
182 | #define KCS_GET_STATUS_ABORT 0x60 | |
183 | #define KCS_WRITE_START 0x61 | |
184 | #define KCS_WRITE_END 0x62 | |
185 | #define KCS_READ_BYTE 0x68 | |
186 | ||
187 | /* Status bits. */ | |
188 | #define GET_STATUS_STATE(status) (((status) >> 6) & 0x03) | |
189 | #define KCS_IDLE_STATE 0 | |
190 | #define KCS_READ_STATE 1 | |
191 | #define KCS_WRITE_STATE 2 | |
192 | #define KCS_ERROR_STATE 3 | |
193 | #define GET_STATUS_ATN(status) ((status) & 0x04) | |
194 | #define GET_STATUS_IBF(status) ((status) & 0x02) | |
195 | #define GET_STATUS_OBF(status) ((status) & 0x01) | |
196 | ||
197 | ||
198 | static inline void write_next_byte(struct si_sm_data *kcs) | |
199 | { | |
200 | write_data(kcs, kcs->write_data[kcs->write_pos]); | |
201 | (kcs->write_pos)++; | |
202 | (kcs->write_count)--; | |
203 | } | |
204 | ||
205 | static inline void start_error_recovery(struct si_sm_data *kcs, char *reason) | |
206 | { | |
207 | (kcs->error_retries)++; | |
208 | if (kcs->error_retries > MAX_ERROR_RETRIES) { | |
c4edff1c | 209 | if (kcs_debug & KCS_DEBUG_ENABLE) |
c305e3d3 CM |
210 | printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n", |
211 | reason); | |
1da177e4 LT |
212 | kcs->state = KCS_HOSED; |
213 | } else { | |
c3e7e791 | 214 | kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES; |
1da177e4 LT |
215 | kcs->state = KCS_ERROR0; |
216 | } | |
217 | } | |
218 | ||
219 | static inline void read_next_byte(struct si_sm_data *kcs) | |
220 | { | |
221 | if (kcs->read_pos >= MAX_KCS_READ_SIZE) { | |
222 | /* Throw the data away and mark it truncated. */ | |
223 | read_data(kcs); | |
224 | kcs->truncated = 1; | |
225 | } else { | |
226 | kcs->read_data[kcs->read_pos] = read_data(kcs); | |
227 | (kcs->read_pos)++; | |
228 | } | |
229 | write_data(kcs, KCS_READ_BYTE); | |
230 | } | |
231 | ||
232 | static inline int check_ibf(struct si_sm_data *kcs, unsigned char status, | |
233 | long time) | |
234 | { | |
235 | if (GET_STATUS_IBF(status)) { | |
236 | kcs->ibf_timeout -= time; | |
237 | if (kcs->ibf_timeout < 0) { | |
238 | start_error_recovery(kcs, "IBF not ready in time"); | |
239 | kcs->ibf_timeout = IBF_RETRY_TIMEOUT; | |
240 | return 1; | |
241 | } | |
242 | return 0; | |
243 | } | |
244 | kcs->ibf_timeout = IBF_RETRY_TIMEOUT; | |
245 | return 1; | |
246 | } | |
247 | ||
248 | static inline int check_obf(struct si_sm_data *kcs, unsigned char status, | |
249 | long time) | |
250 | { | |
8a3628d5 | 251 | if (!GET_STATUS_OBF(status)) { |
1da177e4 LT |
252 | kcs->obf_timeout -= time; |
253 | if (kcs->obf_timeout < 0) { | |
eb6d78ec CM |
254 | kcs->obf_timeout = OBF_RETRY_TIMEOUT; |
255 | start_error_recovery(kcs, "OBF not ready in time"); | |
256 | return 1; | |
1da177e4 LT |
257 | } |
258 | return 0; | |
259 | } | |
260 | kcs->obf_timeout = OBF_RETRY_TIMEOUT; | |
261 | return 1; | |
262 | } | |
263 | ||
264 | static void clear_obf(struct si_sm_data *kcs, unsigned char status) | |
265 | { | |
266 | if (GET_STATUS_OBF(status)) | |
267 | read_data(kcs); | |
268 | } | |
269 | ||
270 | static void restart_kcs_transaction(struct si_sm_data *kcs) | |
271 | { | |
272 | kcs->write_count = kcs->orig_write_count; | |
273 | kcs->write_pos = 0; | |
274 | kcs->read_pos = 0; | |
275 | kcs->state = KCS_WAIT_WRITE_START; | |
276 | kcs->ibf_timeout = IBF_RETRY_TIMEOUT; | |
277 | kcs->obf_timeout = OBF_RETRY_TIMEOUT; | |
278 | write_cmd(kcs, KCS_WRITE_START); | |
279 | } | |
280 | ||
281 | static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data, | |
282 | unsigned int size) | |
283 | { | |
c4edff1c CM |
284 | unsigned int i; |
285 | ||
4d7cbac7 CM |
286 | if (size < 2) |
287 | return IPMI_REQ_LEN_INVALID_ERR; | |
288 | if (size > MAX_KCS_WRITE_SIZE) | |
289 | return IPMI_REQ_LEN_EXCEEDED_ERR; | |
290 | ||
291 | if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED)) | |
292 | return IPMI_NOT_IN_MY_STATE_ERR; | |
293 | ||
c4edff1c CM |
294 | if (kcs_debug & KCS_DEBUG_MSG) { |
295 | printk(KERN_DEBUG "start_kcs_transaction -"); | |
c305e3d3 | 296 | for (i = 0; i < size; i++) |
c4edff1c | 297 | printk(" %02x", (unsigned char) (data [i])); |
c305e3d3 | 298 | printk("\n"); |
c4edff1c | 299 | } |
1da177e4 LT |
300 | kcs->error_retries = 0; |
301 | memcpy(kcs->write_data, data, size); | |
302 | kcs->write_count = size; | |
303 | kcs->orig_write_count = size; | |
304 | kcs->write_pos = 0; | |
305 | kcs->read_pos = 0; | |
306 | kcs->state = KCS_START_OP; | |
307 | kcs->ibf_timeout = IBF_RETRY_TIMEOUT; | |
308 | kcs->obf_timeout = OBF_RETRY_TIMEOUT; | |
309 | return 0; | |
310 | } | |
311 | ||
312 | static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data, | |
313 | unsigned int length) | |
314 | { | |
315 | if (length < kcs->read_pos) { | |
316 | kcs->read_pos = length; | |
317 | kcs->truncated = 1; | |
318 | } | |
319 | ||
320 | memcpy(data, kcs->read_data, kcs->read_pos); | |
321 | ||
322 | if ((length >= 3) && (kcs->read_pos < 3)) { | |
323 | /* Guarantee that we return at least 3 bytes, with an | |
324 | error in the third byte if it is too short. */ | |
325 | data[2] = IPMI_ERR_UNSPECIFIED; | |
326 | kcs->read_pos = 3; | |
327 | } | |
328 | if (kcs->truncated) { | |
c305e3d3 CM |
329 | /* |
330 | * Report a truncated error. We might overwrite | |
331 | * another error, but that's too bad, the user needs | |
332 | * to know it was truncated. | |
333 | */ | |
1da177e4 LT |
334 | data[2] = IPMI_ERR_MSG_TRUNCATED; |
335 | kcs->truncated = 0; | |
336 | } | |
337 | ||
338 | return kcs->read_pos; | |
339 | } | |
340 | ||
c305e3d3 CM |
341 | /* |
342 | * This implements the state machine defined in the IPMI manual, see | |
343 | * that for details on how this works. Divide that flowchart into | |
344 | * sections delimited by "Wait for IBF" and this will become clear. | |
345 | */ | |
1da177e4 LT |
346 | static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time) |
347 | { | |
348 | unsigned char status; | |
349 | unsigned char state; | |
350 | ||
351 | status = read_status(kcs); | |
352 | ||
c4edff1c CM |
353 | if (kcs_debug & KCS_DEBUG_STATES) |
354 | printk(KERN_DEBUG "KCS: State = %d, %x\n", kcs->state, status); | |
355 | ||
1da177e4 LT |
356 | /* All states wait for ibf, so just do it here. */ |
357 | if (!check_ibf(kcs, status, time)) | |
358 | return SI_SM_CALL_WITH_DELAY; | |
359 | ||
360 | /* Just about everything looks at the KCS state, so grab that, too. */ | |
361 | state = GET_STATUS_STATE(status); | |
362 | ||
363 | switch (kcs->state) { | |
364 | case KCS_IDLE: | |
365 | /* If there's and interrupt source, turn it off. */ | |
366 | clear_obf(kcs, status); | |
367 | ||
368 | if (GET_STATUS_ATN(status)) | |
369 | return SI_SM_ATTN; | |
370 | else | |
371 | return SI_SM_IDLE; | |
372 | ||
373 | case KCS_START_OP: | |
d1da96aa | 374 | if (state != KCS_IDLE_STATE) { |
1da177e4 LT |
375 | start_error_recovery(kcs, |
376 | "State machine not idle at start"); | |
377 | break; | |
378 | } | |
379 | ||
380 | clear_obf(kcs, status); | |
381 | write_cmd(kcs, KCS_WRITE_START); | |
382 | kcs->state = KCS_WAIT_WRITE_START; | |
383 | break; | |
384 | ||
385 | case KCS_WAIT_WRITE_START: | |
386 | if (state != KCS_WRITE_STATE) { | |
387 | start_error_recovery( | |
388 | kcs, | |
389 | "Not in write state at write start"); | |
390 | break; | |
391 | } | |
392 | read_data(kcs); | |
393 | if (kcs->write_count == 1) { | |
394 | write_cmd(kcs, KCS_WRITE_END); | |
395 | kcs->state = KCS_WAIT_WRITE_END; | |
396 | } else { | |
397 | write_next_byte(kcs); | |
398 | kcs->state = KCS_WAIT_WRITE; | |
399 | } | |
400 | break; | |
401 | ||
402 | case KCS_WAIT_WRITE: | |
403 | if (state != KCS_WRITE_STATE) { | |
404 | start_error_recovery(kcs, | |
405 | "Not in write state for write"); | |
406 | break; | |
407 | } | |
408 | clear_obf(kcs, status); | |
409 | if (kcs->write_count == 1) { | |
410 | write_cmd(kcs, KCS_WRITE_END); | |
411 | kcs->state = KCS_WAIT_WRITE_END; | |
412 | } else { | |
413 | write_next_byte(kcs); | |
414 | } | |
415 | break; | |
c305e3d3 | 416 | |
1da177e4 LT |
417 | case KCS_WAIT_WRITE_END: |
418 | if (state != KCS_WRITE_STATE) { | |
419 | start_error_recovery(kcs, | |
c305e3d3 CM |
420 | "Not in write state" |
421 | " for write end"); | |
1da177e4 LT |
422 | break; |
423 | } | |
424 | clear_obf(kcs, status); | |
425 | write_next_byte(kcs); | |
426 | kcs->state = KCS_WAIT_READ; | |
427 | break; | |
428 | ||
429 | case KCS_WAIT_READ: | |
430 | if ((state != KCS_READ_STATE) && (state != KCS_IDLE_STATE)) { | |
431 | start_error_recovery( | |
432 | kcs, | |
433 | "Not in read or idle in read state"); | |
434 | break; | |
435 | } | |
436 | ||
437 | if (state == KCS_READ_STATE) { | |
8a3628d5 | 438 | if (!check_obf(kcs, status, time)) |
1da177e4 LT |
439 | return SI_SM_CALL_WITH_DELAY; |
440 | read_next_byte(kcs); | |
441 | } else { | |
c305e3d3 CM |
442 | /* |
443 | * We don't implement this exactly like the state | |
444 | * machine in the spec. Some broken hardware | |
445 | * does not write the final dummy byte to the | |
446 | * read register. Thus obf will never go high | |
447 | * here. We just go straight to idle, and we | |
448 | * handle clearing out obf in idle state if it | |
449 | * happens to come in. | |
450 | */ | |
1da177e4 LT |
451 | clear_obf(kcs, status); |
452 | kcs->orig_write_count = 0; | |
453 | kcs->state = KCS_IDLE; | |
454 | return SI_SM_TRANSACTION_COMPLETE; | |
455 | } | |
456 | break; | |
457 | ||
458 | case KCS_ERROR0: | |
459 | clear_obf(kcs, status); | |
c3e7e791 | 460 | status = read_status(kcs); |
c305e3d3 CM |
461 | if (GET_STATUS_OBF(status)) |
462 | /* controller isn't responding */ | |
c3e7e791 CM |
463 | if (time_before(jiffies, kcs->error0_timeout)) |
464 | return SI_SM_CALL_WITH_TICK_DELAY; | |
1da177e4 LT |
465 | write_cmd(kcs, KCS_GET_STATUS_ABORT); |
466 | kcs->state = KCS_ERROR1; | |
467 | break; | |
468 | ||
469 | case KCS_ERROR1: | |
470 | clear_obf(kcs, status); | |
471 | write_data(kcs, 0); | |
472 | kcs->state = KCS_ERROR2; | |
473 | break; | |
c305e3d3 | 474 | |
1da177e4 LT |
475 | case KCS_ERROR2: |
476 | if (state != KCS_READ_STATE) { | |
477 | start_error_recovery(kcs, | |
478 | "Not in read state for error2"); | |
479 | break; | |
480 | } | |
8a3628d5 | 481 | if (!check_obf(kcs, status, time)) |
1da177e4 LT |
482 | return SI_SM_CALL_WITH_DELAY; |
483 | ||
484 | clear_obf(kcs, status); | |
485 | write_data(kcs, KCS_READ_BYTE); | |
486 | kcs->state = KCS_ERROR3; | |
487 | break; | |
c305e3d3 | 488 | |
1da177e4 LT |
489 | case KCS_ERROR3: |
490 | if (state != KCS_IDLE_STATE) { | |
491 | start_error_recovery(kcs, | |
492 | "Not in idle state for error3"); | |
493 | break; | |
494 | } | |
495 | ||
8a3628d5 | 496 | if (!check_obf(kcs, status, time)) |
1da177e4 LT |
497 | return SI_SM_CALL_WITH_DELAY; |
498 | ||
499 | clear_obf(kcs, status); | |
500 | if (kcs->orig_write_count) { | |
501 | restart_kcs_transaction(kcs); | |
502 | } else { | |
503 | kcs->state = KCS_IDLE; | |
504 | return SI_SM_TRANSACTION_COMPLETE; | |
505 | } | |
506 | break; | |
c305e3d3 | 507 | |
1da177e4 LT |
508 | case KCS_HOSED: |
509 | break; | |
510 | } | |
511 | ||
512 | if (kcs->state == KCS_HOSED) { | |
513 | init_kcs_data(kcs, kcs->io); | |
514 | return SI_SM_HOSED; | |
515 | } | |
516 | ||
517 | return SI_SM_CALL_WITHOUT_DELAY; | |
518 | } | |
519 | ||
520 | static int kcs_size(void) | |
521 | { | |
522 | return sizeof(struct si_sm_data); | |
523 | } | |
524 | ||
525 | static int kcs_detect(struct si_sm_data *kcs) | |
526 | { | |
c305e3d3 CM |
527 | /* |
528 | * It's impossible for the KCS status register to be all 1's, | |
529 | * (assuming a properly functioning, self-initialized BMC) | |
530 | * but that's what you get from reading a bogus address, so we | |
531 | * test that first. | |
532 | */ | |
1da177e4 LT |
533 | if (read_status(kcs) == 0xff) |
534 | return 1; | |
535 | ||
536 | return 0; | |
537 | } | |
538 | ||
539 | static void kcs_cleanup(struct si_sm_data *kcs) | |
540 | { | |
541 | } | |
542 | ||
81d02b7f | 543 | const struct si_sm_handlers kcs_smi_handlers = { |
1da177e4 LT |
544 | .init_data = init_kcs_data, |
545 | .start_transaction = start_kcs_transaction, | |
546 | .get_result = get_kcs_result, | |
547 | .event = kcs_event, | |
548 | .detect = kcs_detect, | |
549 | .cleanup = kcs_cleanup, | |
550 | .size = kcs_size, | |
551 | }; |