blob: 053de11e7258b2204782193d2bda03a19879adbc [file] [log] [blame]
Jeremy Kerr3d36ee22019-05-30 11:15:37 +08001/* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */
Jeremy Kerr672c8852019-03-01 12:18:07 +08002
Andrew Jeffery3286f172020-03-17 23:04:13 +10303#if HAVE_CONFIG_H
4#include "config.h"
5#endif
6
7#if HAVE_ENDIAN_H
Jeremy Kerr92a10a62019-08-28 16:55:54 +05308#include <endian.h>
Andrew Jeffery3286f172020-03-17 23:04:13 +10309#endif
10
11#include <assert.h>
Andrew Jeffery59c6a5c2020-01-17 15:52:51 +103012#include <err.h>
Andrew Jeffery7cd72f12020-05-12 20:27:59 +093013#include <errno.h>
Andrew Jefferyedfe3832020-02-06 11:52:11 +103014#include <inttypes.h>
Jeremy Kerr672c8852019-03-01 12:18:07 +080015#include <stdbool.h>
16#include <stdlib.h>
17#include <string.h>
Jeremy Kerr672c8852019-03-01 12:18:07 +080018
Jeremy Kerr672c8852019-03-01 12:18:07 +080019#define pr_fmt(x) "astlpc: " x
20
Andrew Jefferyeba19a32021-03-09 23:09:40 +103021#include "container_of.h"
22#include "crc32.h"
Jeremy Kerr672c8852019-03-01 12:18:07 +080023#include "libmctp.h"
24#include "libmctp-alloc.h"
25#include "libmctp-log.h"
26#include "libmctp-astlpc.h"
Andrew Jeffery4622cad2020-11-03 22:20:18 +103027#include "range.h"
Jeremy Kerr672c8852019-03-01 12:18:07 +080028
Jeremy Kerrb214c642019-11-27 11:34:00 +080029#ifdef MCTP_HAVE_FILEIO
Jeremy Kerr92a10a62019-08-28 16:55:54 +053030
Jeremy Kerrc6f676d2019-12-19 09:24:06 +080031#include <unistd.h>
Jeremy Kerr92a10a62019-08-28 16:55:54 +053032#include <fcntl.h>
33#include <sys/ioctl.h>
34#include <sys/mman.h>
35#include <linux/aspeed-lpc-ctrl.h>
36
37/* kernel interface */
38static const char *kcs_path = "/dev/mctp0";
39static const char *lpc_path = "/dev/aspeed-lpc-ctrl";
40
41#endif
42
Andrew Jeffery7cd72f12020-05-12 20:27:59 +093043struct mctp_astlpc_buffer {
44 uint32_t offset;
45 uint32_t size;
46};
47
48struct mctp_astlpc_layout {
49 struct mctp_astlpc_buffer rx;
50 struct mctp_astlpc_buffer tx;
51};
52
Andrew Jeffery88412be2021-03-09 22:05:22 +103053struct mctp_astlpc_protocol {
54 uint16_t version;
55 uint32_t (*packet_size)(uint32_t body);
56 uint32_t (*body_size)(uint32_t packet);
Andrew Jefferyeba19a32021-03-09 23:09:40 +103057 void (*pktbuf_protect)(struct mctp_pktbuf *pkt);
58 bool (*pktbuf_validate)(struct mctp_pktbuf *pkt);
Andrew Jeffery88412be2021-03-09 22:05:22 +103059};
60
Jeremy Kerr672c8852019-03-01 12:18:07 +080061struct mctp_binding_astlpc {
62 struct mctp_binding binding;
Jeremy Kerrbc53d352019-08-28 14:26:14 +053063
Andrew Jeffery55fb90b2020-05-12 13:54:37 +093064 void *lpc_map;
Andrew Jeffery7cd72f12020-05-12 20:27:59 +093065 struct mctp_astlpc_layout layout;
66
67 uint8_t mode;
Andrew Jefferya9368982020-06-09 13:07:39 +093068 uint32_t requested_mtu;
Jeremy Kerrbc53d352019-08-28 14:26:14 +053069
Andrew Jeffery88412be2021-03-09 22:05:22 +103070 const struct mctp_astlpc_protocol *proto;
71
Jeremy Kerrbc53d352019-08-28 14:26:14 +053072 /* direct ops data */
Andrew Jeffery55fb90b2020-05-12 13:54:37 +093073 struct mctp_binding_astlpc_ops ops;
74 void *ops_data;
Jeremy Kerrbc53d352019-08-28 14:26:14 +053075
76 /* fileio ops data */
Andrew Jeffery979c6a12020-05-23 20:04:49 +093077 int kcs_fd;
78 uint8_t kcs_status;
Jeremy Kerr672c8852019-03-01 12:18:07 +080079
80 bool running;
Jeremy Kerr672c8852019-03-01 12:18:07 +080081};
82
Jeremy Kerr672c8852019-03-01 12:18:07 +080083#define binding_to_astlpc(b) \
84 container_of(b, struct mctp_binding_astlpc, binding)
85
Andrew Jeffery9101a2a2020-05-22 16:08:03 +093086#define astlpc_prlog(ctx, lvl, fmt, ...) \
87 do { \
88 bool __bmc = ((ctx)->mode == MCTP_BINDING_ASTLPC_MODE_BMC); \
89 mctp_prlog(lvl, pr_fmt("%s: " fmt), __bmc ? "bmc" : "host", \
90 ##__VA_ARGS__); \
91 } while (0)
92
93#define astlpc_prerr(ctx, fmt, ...) \
94 astlpc_prlog(ctx, MCTP_LOG_ERR, fmt, ##__VA_ARGS__)
95#define astlpc_prwarn(ctx, fmt, ...) \
96 astlpc_prlog(ctx, MCTP_LOG_WARNING, fmt, ##__VA_ARGS__)
97#define astlpc_prinfo(ctx, fmt, ...) \
98 astlpc_prlog(ctx, MCTP_LOG_INFO, fmt, ##__VA_ARGS__)
99#define astlpc_prdebug(ctx, fmt, ...) \
100 astlpc_prlog(ctx, MCTP_LOG_DEBUG, fmt, ##__VA_ARGS__)
101
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930102/* clang-format off */
103#define ASTLPC_MCTP_MAGIC 0x4d435450
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930104#define ASTLPC_VER_BAD 0
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930105#define ASTLPC_VER_MIN 1
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930106
Andrew Jeffery3a540662020-05-26 19:55:30 +0930107/* Support testing of new binding protocols */
108#ifndef ASTLPC_VER_CUR
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030109#define ASTLPC_VER_CUR 3
Andrew Jeffery3a540662020-05-26 19:55:30 +0930110#endif
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930111/* clang-format on */
Jeremy Kerr672c8852019-03-01 12:18:07 +0800112
Andrew Jeffery88412be2021-03-09 22:05:22 +1030113#ifndef ARRAY_SIZE
114#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
115#endif
116
117static uint32_t astlpc_packet_size_v1(uint32_t body)
118{
119 assert((body + 4) > body);
120
121 return body + 4;
122}
123
124static uint32_t astlpc_body_size_v1(uint32_t packet)
125{
126 assert((packet - 4) < packet);
127
128 return packet - 4;
129}
130
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030131void astlpc_pktbuf_protect_v1(struct mctp_pktbuf *pkt)
132{
133 (void)pkt;
134}
135
136bool astlpc_pktbuf_validate_v1(struct mctp_pktbuf *pkt)
137{
138 (void)pkt;
139 return true;
140}
141
142static uint32_t astlpc_packet_size_v3(uint32_t body)
143{
144 assert((body + 4 + 4) > body);
145
146 return body + 4 + 4;
147}
148
149static uint32_t astlpc_body_size_v3(uint32_t packet)
150{
151 assert((packet - 4 - 4) < packet);
152
153 return packet - 4 - 4;
154}
155
156void astlpc_pktbuf_protect_v3(struct mctp_pktbuf *pkt)
157{
158 uint32_t code;
159
160 code = htobe32(crc32(mctp_pktbuf_hdr(pkt), mctp_pktbuf_size(pkt)));
161 mctp_prdebug("%s: 0x%" PRIx32, __func__, code);
162 mctp_pktbuf_push(pkt, &code, 4);
163}
164
165bool astlpc_pktbuf_validate_v3(struct mctp_pktbuf *pkt)
166{
167 uint32_t code;
168 void *check;
169
170 code = be32toh(crc32(mctp_pktbuf_hdr(pkt), mctp_pktbuf_size(pkt) - 4));
171 mctp_prdebug("%s: 0x%" PRIx32, __func__, code);
172 check = mctp_pktbuf_pop(pkt, 4);
173 return check && !memcmp(&code, check, 4);
174}
175
Andrew Jeffery88412be2021-03-09 22:05:22 +1030176static const struct mctp_astlpc_protocol astlpc_protocol_version[] = {
177 [0] = {
178 .version = 0,
179 .packet_size = NULL,
180 .body_size = NULL,
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030181 .pktbuf_protect = NULL,
182 .pktbuf_validate = NULL,
Andrew Jeffery88412be2021-03-09 22:05:22 +1030183 },
184 [1] = {
185 .version = 1,
186 .packet_size = astlpc_packet_size_v1,
187 .body_size = astlpc_body_size_v1,
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030188 .pktbuf_protect = astlpc_pktbuf_protect_v1,
189 .pktbuf_validate = astlpc_pktbuf_validate_v1,
Andrew Jeffery88412be2021-03-09 22:05:22 +1030190 },
191 [2] = {
192 .version = 2,
193 .packet_size = astlpc_packet_size_v1,
194 .body_size = astlpc_body_size_v1,
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030195 .pktbuf_protect = astlpc_pktbuf_protect_v1,
196 .pktbuf_validate = astlpc_pktbuf_validate_v1,
197 },
198 [3] = {
199 .version = 3,
200 .packet_size = astlpc_packet_size_v3,
201 .body_size = astlpc_body_size_v3,
202 .pktbuf_protect = astlpc_pktbuf_protect_v3,
203 .pktbuf_validate = astlpc_pktbuf_validate_v3,
Andrew Jeffery88412be2021-03-09 22:05:22 +1030204 },
205};
206
Jeremy Kerr672c8852019-03-01 12:18:07 +0800207struct mctp_lpcmap_hdr {
Andrew Jeffery3a540662020-05-26 19:55:30 +0930208 uint32_t magic;
Jeremy Kerr672c8852019-03-01 12:18:07 +0800209
Andrew Jeffery3a540662020-05-26 19:55:30 +0930210 uint16_t bmc_ver_min;
211 uint16_t bmc_ver_cur;
212 uint16_t host_ver_min;
213 uint16_t host_ver_cur;
214 uint16_t negotiated_ver;
215 uint16_t pad0;
Jeremy Kerr672c8852019-03-01 12:18:07 +0800216
Andrew Jeffery3a540662020-05-26 19:55:30 +0930217 struct {
218 uint32_t rx_offset;
219 uint32_t rx_size;
220 uint32_t tx_offset;
221 uint32_t tx_size;
222 } layout;
Jeremy Kerr672c8852019-03-01 12:18:07 +0800223} __attribute__((packed));
224
Andrew Jeffery3a540662020-05-26 19:55:30 +0930225static const uint32_t control_size = 0x100;
Jeremy Kerr672c8852019-03-01 12:18:07 +0800226
Jeremy Kerr672c8852019-03-01 12:18:07 +0800227#define LPC_WIN_SIZE (1 * 1024 * 1024)
228
Jeremy Kerr672c8852019-03-01 12:18:07 +0800229#define KCS_STATUS_BMC_READY 0x80
230#define KCS_STATUS_CHANNEL_ACTIVE 0x40
231#define KCS_STATUS_IBF 0x02
232#define KCS_STATUS_OBF 0x01
233
Andrew Jefferyf13cb972020-05-28 09:30:09 +0930234static inline int mctp_astlpc_kcs_write(struct mctp_binding_astlpc *astlpc,
235 enum mctp_binding_astlpc_kcs_reg reg,
236 uint8_t val)
237{
238 return astlpc->ops.kcs_write(astlpc->ops_data, reg, val);
239}
240
241static inline int mctp_astlpc_kcs_read(struct mctp_binding_astlpc *astlpc,
242 enum mctp_binding_astlpc_kcs_reg reg,
243 uint8_t *val)
244{
245 return astlpc->ops.kcs_read(astlpc->ops_data, reg, val);
246}
247
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930248static inline int mctp_astlpc_lpc_write(struct mctp_binding_astlpc *astlpc,
249 const void *buf, long offset,
250 size_t len)
Jeremy Kerrbc53d352019-08-28 14:26:14 +0530251{
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930252 astlpc_prdebug(astlpc, "%s: %zu bytes to 0x%lx", __func__, len, offset);
253
254 assert(offset >= 0);
255
256 /* Indirect access */
257 if (astlpc->ops.lpc_write) {
258 void *data = astlpc->ops_data;
259
260 return astlpc->ops.lpc_write(data, buf, offset, len);
261 }
262
263 /* Direct mapping */
264 assert(astlpc->lpc_map);
265 memcpy(&((char *)astlpc->lpc_map)[offset], buf, len);
266
267 return 0;
268}
269
270static inline int mctp_astlpc_lpc_read(struct mctp_binding_astlpc *astlpc,
271 void *buf, long offset, size_t len)
272{
273 astlpc_prdebug(astlpc, "%s: %zu bytes from 0x%lx", __func__, len,
274 offset);
275
276 assert(offset >= 0);
277
278 /* Indirect access */
279 if (astlpc->ops.lpc_read) {
280 void *data = astlpc->ops_data;
281
282 return astlpc->ops.lpc_read(data, buf, offset, len);
283 }
284
285 /* Direct mapping */
286 assert(astlpc->lpc_map);
287 memcpy(buf, &((char *)astlpc->lpc_map)[offset], len);
288
289 return 0;
Jeremy Kerrbc53d352019-08-28 14:26:14 +0530290}
291
Andrew Jefferyd0f5da02020-05-28 09:12:55 +0930292static int mctp_astlpc_kcs_set_status(struct mctp_binding_astlpc *astlpc,
293 uint8_t status)
294{
295 uint8_t data;
296 int rc;
297
298 /* Since we're setting the status register, we want the other endpoint
299 * to be interrupted. However, some hardware may only raise a host-side
300 * interrupt on an ODR event.
301 * So, write a dummy value of 0xff to ODR, which will ensure that an
302 * interrupt is triggered, and can be ignored by the host.
303 */
304 data = 0xff;
Andrew Jefferyd0f5da02020-05-28 09:12:55 +0930305
Andrew Jefferyf13cb972020-05-28 09:30:09 +0930306 rc = mctp_astlpc_kcs_write(astlpc, MCTP_ASTLPC_KCS_REG_STATUS, status);
Andrew Jefferyd0f5da02020-05-28 09:12:55 +0930307 if (rc) {
308 astlpc_prwarn(astlpc, "KCS status write failed");
309 return -1;
310 }
311
Andrew Jefferyf13cb972020-05-28 09:30:09 +0930312 rc = mctp_astlpc_kcs_write(astlpc, MCTP_ASTLPC_KCS_REG_DATA, data);
Andrew Jefferyd0f5da02020-05-28 09:12:55 +0930313 if (rc) {
314 astlpc_prwarn(astlpc, "KCS dummy data write failed");
315 return -1;
316 }
317
318 return 0;
319}
320
Andrew Jeffery3a540662020-05-26 19:55:30 +0930321static int mctp_astlpc_layout_read(struct mctp_binding_astlpc *astlpc,
322 struct mctp_astlpc_layout *layout)
323{
324 struct mctp_lpcmap_hdr hdr;
325 int rc;
326
327 rc = mctp_astlpc_lpc_read(astlpc, &hdr, 0, sizeof(hdr));
328 if (rc < 0)
329 return rc;
330
331 /* Flip the buffers as the names are defined in terms of the host */
332 if (astlpc->mode == MCTP_BINDING_ASTLPC_MODE_BMC) {
333 layout->rx.offset = be32toh(hdr.layout.tx_offset);
334 layout->rx.size = be32toh(hdr.layout.tx_size);
335 layout->tx.offset = be32toh(hdr.layout.rx_offset);
336 layout->tx.size = be32toh(hdr.layout.rx_size);
337 } else {
338 assert(astlpc->mode == MCTP_BINDING_ASTLPC_MODE_HOST);
339
340 layout->rx.offset = be32toh(hdr.layout.rx_offset);
341 layout->rx.size = be32toh(hdr.layout.rx_size);
342 layout->tx.offset = be32toh(hdr.layout.tx_offset);
343 layout->tx.size = be32toh(hdr.layout.tx_size);
344 }
345
346 return 0;
347}
348
349static int mctp_astlpc_layout_write(struct mctp_binding_astlpc *astlpc,
350 struct mctp_astlpc_layout *layout)
351{
352 uint32_t rx_size_be;
353
354 if (astlpc->mode == MCTP_BINDING_ASTLPC_MODE_BMC) {
355 struct mctp_lpcmap_hdr hdr;
356
357 /*
358 * Flip the buffers as the names are defined in terms of the
359 * host
360 */
361 hdr.layout.rx_offset = htobe32(layout->tx.offset);
362 hdr.layout.rx_size = htobe32(layout->tx.size);
363 hdr.layout.tx_offset = htobe32(layout->rx.offset);
364 hdr.layout.tx_size = htobe32(layout->rx.size);
365
366 return mctp_astlpc_lpc_write(astlpc, &hdr.layout,
367 offsetof(struct mctp_lpcmap_hdr, layout),
368 sizeof(hdr.layout));
369 }
370
371 assert(astlpc->mode == MCTP_BINDING_ASTLPC_MODE_HOST);
372
373 /*
374 * As of v2 we only need to write rx_size - the offsets are controlled
375 * by the BMC, as is the BMC's rx_size (host tx_size).
376 */
377 rx_size_be = htobe32(layout->rx.size);
378 return mctp_astlpc_lpc_write(astlpc, &rx_size_be,
379 offsetof(struct mctp_lpcmap_hdr, layout.rx_size),
380 sizeof(rx_size_be));
381}
382
Andrew Jeffery88412be2021-03-09 22:05:22 +1030383static bool
384mctp_astlpc_buffer_validate(const struct mctp_binding_astlpc *astlpc,
385 const struct mctp_astlpc_buffer *buf,
386 const char *name)
Andrew Jeffery3a540662020-05-26 19:55:30 +0930387{
388 /* Check for overflow */
389 if (buf->offset + buf->size < buf->offset) {
390 mctp_prerr(
391 "%s packet buffer parameters overflow: offset: 0x%" PRIx32
392 ", size: %" PRIu32,
393 name, buf->offset, buf->size);
394 return false;
395 }
396
397 /* Check that the buffers are contained within the allocated space */
398 if (buf->offset + buf->size > LPC_WIN_SIZE) {
399 mctp_prerr(
400 "%s packet buffer parameters exceed %uM window size: offset: 0x%" PRIx32
401 ", size: %" PRIu32,
402 name, (LPC_WIN_SIZE / (1024 * 1024)), buf->offset,
403 buf->size);
404 return false;
405 }
406
407 /* Check that the baseline transmission unit is supported */
Andrew Jeffery88412be2021-03-09 22:05:22 +1030408 if (buf->size < astlpc->proto->packet_size(MCTP_PACKET_SIZE(MCTP_BTU))) {
Andrew Jeffery3a540662020-05-26 19:55:30 +0930409 mctp_prerr(
Andrew Jeffery88412be2021-03-09 22:05:22 +1030410 "%s packet buffer too small: Require %" PRIu32 " bytes to support the %u byte baseline transmission unit, found %" PRIu32,
411 name,
412 astlpc->proto->packet_size(MCTP_PACKET_SIZE(MCTP_BTU)),
Andrew Jeffery3a540662020-05-26 19:55:30 +0930413 MCTP_BTU, buf->size);
414 return false;
415 }
416
417 /* Check for overlap with the control space */
418 if (buf->offset < control_size) {
419 mctp_prerr(
420 "%s packet buffer overlaps control region {0x%" PRIx32
421 ", %" PRIu32 "}: Rx {0x%" PRIx32 ", %" PRIu32 "}",
422 name, 0U, control_size, buf->offset, buf->size);
423 return false;
424 }
425
426 return true;
427}
428
Andrew Jeffery88412be2021-03-09 22:05:22 +1030429static bool
430mctp_astlpc_layout_validate(const struct mctp_binding_astlpc *astlpc,
431 const struct mctp_astlpc_layout *layout)
Andrew Jeffery3a540662020-05-26 19:55:30 +0930432{
Andrew Jeffery88412be2021-03-09 22:05:22 +1030433 const struct mctp_astlpc_buffer *rx = &layout->rx;
434 const struct mctp_astlpc_buffer *tx = &layout->tx;
Andrew Jeffery3a540662020-05-26 19:55:30 +0930435 bool rx_valid, tx_valid;
436
Andrew Jeffery88412be2021-03-09 22:05:22 +1030437 rx_valid = mctp_astlpc_buffer_validate(astlpc, rx, "Rx");
438 tx_valid = mctp_astlpc_buffer_validate(astlpc, tx, "Tx");
Andrew Jeffery3a540662020-05-26 19:55:30 +0930439
440 if (!(rx_valid && tx_valid))
441 return false;
442
443 /* Check that the buffers are disjoint */
444 if ((rx->offset <= tx->offset && rx->offset + rx->size > tx->offset) ||
445 (tx->offset <= rx->offset && tx->offset + tx->size > rx->offset)) {
446 mctp_prerr("Rx and Tx packet buffers overlap: Rx {0x%" PRIx32
447 ", %" PRIu32 "}, Tx {0x%" PRIx32 ", %" PRIu32 "}",
448 rx->offset, rx->size, tx->offset, tx->size);
449 return false;
450 }
451
452 return true;
453}
454
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930455static int mctp_astlpc_init_bmc(struct mctp_binding_astlpc *astlpc)
456{
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930457 struct mctp_lpcmap_hdr hdr = { 0 };
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930458 uint8_t status;
Andrew Jeffery88412be2021-03-09 22:05:22 +1030459 uint32_t sz;
Andrew Jeffery3a540662020-05-26 19:55:30 +0930460
461 /*
462 * The largest buffer size is half of the allocated MCTP space
463 * excluding the control space.
464 */
465 sz = ((LPC_WIN_SIZE - control_size) / 2);
466
467 /*
468 * Trim the MTU to a multiple of 16 to meet the requirements of 12.17
469 * Query Hop in DSP0236 v1.3.0.
470 */
Andrew Jeffery88412be2021-03-09 22:05:22 +1030471 sz = MCTP_BODY_SIZE(astlpc->proto->body_size(sz));
Andrew Jeffery3a540662020-05-26 19:55:30 +0930472 sz &= ~0xfUL;
Andrew Jeffery88412be2021-03-09 22:05:22 +1030473 sz = astlpc->proto->packet_size(MCTP_PACKET_SIZE(sz));
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930474
Andrew Jefferya9368982020-06-09 13:07:39 +0930475 if (astlpc->requested_mtu) {
Andrew Jeffery88412be2021-03-09 22:05:22 +1030476 uint32_t rpkt, rmtu;
Andrew Jefferya9368982020-06-09 13:07:39 +0930477
Andrew Jeffery88412be2021-03-09 22:05:22 +1030478 rmtu = astlpc->requested_mtu;
479 rpkt = astlpc->proto->packet_size(MCTP_PACKET_SIZE(rmtu));
480 sz = MIN(sz, rpkt);
Andrew Jefferya9368982020-06-09 13:07:39 +0930481 }
482
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930483 /* Flip the buffers as the names are defined in terms of the host */
Andrew Jeffery3a540662020-05-26 19:55:30 +0930484 astlpc->layout.tx.offset = control_size;
485 astlpc->layout.tx.size = sz;
486 astlpc->layout.rx.offset =
487 astlpc->layout.tx.offset + astlpc->layout.tx.size;
488 astlpc->layout.rx.size = sz;
489
Andrew Jeffery88412be2021-03-09 22:05:22 +1030490 if (!mctp_astlpc_layout_validate(astlpc, &astlpc->layout)) {
491 astlpc_prerr(astlpc, "Cannot support an MTU of %" PRIu32, sz);
Andrew Jefferya9368982020-06-09 13:07:39 +0930492 return -EINVAL;
493 }
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930494
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930495 hdr = (struct mctp_lpcmap_hdr){
496 .magic = htobe32(ASTLPC_MCTP_MAGIC),
497 .bmc_ver_min = htobe16(ASTLPC_VER_MIN),
498 .bmc_ver_cur = htobe16(ASTLPC_VER_CUR),
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930499
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930500 /* Flip the buffers back as we're now describing the host's
501 * configuration to the host */
Andrew Jeffery3a540662020-05-26 19:55:30 +0930502 .layout.rx_offset = htobe32(astlpc->layout.tx.offset),
503 .layout.rx_size = htobe32(astlpc->layout.tx.size),
504 .layout.tx_offset = htobe32(astlpc->layout.rx.offset),
505 .layout.tx_size = htobe32(astlpc->layout.rx.size),
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930506 };
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930507
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930508 mctp_astlpc_lpc_write(astlpc, &hdr, 0, sizeof(hdr));
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930509
Andrew Jefferyb3b55a62020-07-06 13:34:18 +0930510 /*
511 * Set status indicating that the BMC is now active. Be explicit about
512 * clearing OBF; we're reinitialising the binding and so any previous
513 * buffer state is irrelevant.
514 */
515 status = KCS_STATUS_BMC_READY & ~KCS_STATUS_OBF;
Andrew Jefferyd0f5da02020-05-28 09:12:55 +0930516 return mctp_astlpc_kcs_set_status(astlpc, status);
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930517}
518
519static int mctp_binding_astlpc_start_bmc(struct mctp_binding *b)
520{
521 struct mctp_binding_astlpc *astlpc =
522 container_of(b, struct mctp_binding_astlpc, binding);
523
Andrew Jeffery88412be2021-03-09 22:05:22 +1030524 astlpc->proto = &astlpc_protocol_version[ASTLPC_VER_CUR];
525
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930526 return mctp_astlpc_init_bmc(astlpc);
527}
528
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930529static bool mctp_astlpc_validate_version(uint16_t bmc_ver_min,
530 uint16_t bmc_ver_cur,
531 uint16_t host_ver_min,
532 uint16_t host_ver_cur)
533{
534 if (!(bmc_ver_min && bmc_ver_cur && host_ver_min && host_ver_cur)) {
535 mctp_prerr("Invalid version present in [%" PRIu16 ", %" PRIu16
536 "], [%" PRIu16 ", %" PRIu16 "]",
537 bmc_ver_min, bmc_ver_cur, host_ver_min,
538 host_ver_cur);
539 return false;
540 } else if (bmc_ver_min > bmc_ver_cur) {
541 mctp_prerr("Invalid bmc version range [%" PRIu16 ", %" PRIu16
542 "]",
543 bmc_ver_min, bmc_ver_cur);
544 return false;
545 } else if (host_ver_min > host_ver_cur) {
546 mctp_prerr("Invalid host version range [%" PRIu16 ", %" PRIu16
547 "]",
548 host_ver_min, host_ver_cur);
549 return false;
550 } else if ((host_ver_cur < bmc_ver_min) ||
551 (host_ver_min > bmc_ver_cur)) {
552 mctp_prerr(
553 "Unable to satisfy version negotiation with ranges [%" PRIu16
554 ", %" PRIu16 "] and [%" PRIu16 ", %" PRIu16 "]",
555 bmc_ver_min, bmc_ver_cur, host_ver_min, host_ver_cur);
556 return false;
557 }
558
559 return true;
560}
561
Andrew Jeffery3a540662020-05-26 19:55:30 +0930562static int mctp_astlpc_negotiate_layout_host(struct mctp_binding_astlpc *astlpc)
563{
564 struct mctp_astlpc_layout layout;
Andrew Jeffery88412be2021-03-09 22:05:22 +1030565 uint32_t rmtu;
Andrew Jeffery3a540662020-05-26 19:55:30 +0930566 uint32_t sz;
567 int rc;
568
569 rc = mctp_astlpc_layout_read(astlpc, &layout);
570 if (rc < 0)
571 return rc;
572
Andrew Jeffery88412be2021-03-09 22:05:22 +1030573 if (!mctp_astlpc_layout_validate(astlpc, &layout)) {
Andrew Jeffery3a540662020-05-26 19:55:30 +0930574 astlpc_prerr(
575 astlpc,
576 "BMC provided invalid buffer layout: Rx {0x%" PRIx32
577 ", %" PRIu32 "}, Tx {0x%" PRIx32 ", %" PRIu32 "}",
578 layout.rx.offset, layout.rx.size, layout.tx.offset,
579 layout.tx.size);
580 return -EINVAL;
581 }
582
Andrew Jefferya9368982020-06-09 13:07:39 +0930583 astlpc_prinfo(astlpc, "Desire an MTU of %" PRIu32 " bytes",
584 astlpc->requested_mtu);
585
Andrew Jeffery88412be2021-03-09 22:05:22 +1030586 rmtu = astlpc->requested_mtu;
587 sz = astlpc->proto->packet_size(MCTP_PACKET_SIZE(rmtu));
Andrew Jeffery3a540662020-05-26 19:55:30 +0930588 layout.rx.size = sz;
589
Andrew Jeffery88412be2021-03-09 22:05:22 +1030590 if (!mctp_astlpc_layout_validate(astlpc, &layout)) {
Andrew Jeffery3a540662020-05-26 19:55:30 +0930591 astlpc_prerr(
592 astlpc,
593 "Generated invalid buffer layout with size %" PRIu32
594 ": Rx {0x%" PRIx32 ", %" PRIu32 "}, Tx {0x%" PRIx32
595 ", %" PRIu32 "}",
596 sz, layout.rx.offset, layout.rx.size, layout.tx.offset,
597 layout.tx.size);
598 return -EINVAL;
599 }
600
Andrew Jefferya9368982020-06-09 13:07:39 +0930601 astlpc_prinfo(astlpc, "Requesting MTU of %" PRIu32 " bytes",
602 astlpc->requested_mtu);
Andrew Jeffery3a540662020-05-26 19:55:30 +0930603
604 return mctp_astlpc_layout_write(astlpc, &layout);
605}
606
Andrew Jeffery88412be2021-03-09 22:05:22 +1030607static uint16_t mctp_astlpc_negotiate_version(uint16_t bmc_ver_min,
608 uint16_t bmc_ver_cur,
609 uint16_t host_ver_min,
610 uint16_t host_ver_cur)
611{
612 if (!mctp_astlpc_validate_version(bmc_ver_min, bmc_ver_cur,
613 host_ver_min, host_ver_cur))
614 return ASTLPC_VER_BAD;
615
616 if (bmc_ver_cur < host_ver_cur)
617 return bmc_ver_cur;
618
619 return host_ver_cur;
620}
621
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930622static int mctp_astlpc_init_host(struct mctp_binding_astlpc *astlpc)
623{
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930624 const uint16_t ver_min_be = htobe16(ASTLPC_VER_MIN);
625 const uint16_t ver_cur_be = htobe16(ASTLPC_VER_CUR);
Andrew Jeffery88412be2021-03-09 22:05:22 +1030626 uint16_t bmc_ver_min, bmc_ver_cur, negotiated;
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930627 struct mctp_lpcmap_hdr hdr;
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930628 uint8_t status;
629 int rc;
630
Andrew Jefferyf13cb972020-05-28 09:30:09 +0930631 rc = mctp_astlpc_kcs_read(astlpc, MCTP_ASTLPC_KCS_REG_STATUS, &status);
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930632 if (rc) {
633 mctp_prwarn("KCS status read failed");
634 return rc;
635 }
636
637 astlpc->kcs_status = status;
638
639 if (!(status & KCS_STATUS_BMC_READY))
640 return -EHOSTDOWN;
641
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930642 mctp_astlpc_lpc_read(astlpc, &hdr, 0, sizeof(hdr));
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930643
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930644 bmc_ver_min = be16toh(hdr.bmc_ver_min);
645 bmc_ver_cur = be16toh(hdr.bmc_ver_cur);
646
Andrew Jeffery88412be2021-03-09 22:05:22 +1030647 /* Calculate the expected value of negotiated_ver */
648 negotiated = mctp_astlpc_negotiate_version(bmc_ver_min, bmc_ver_cur,
649 ASTLPC_VER_MIN,
650 ASTLPC_VER_CUR);
651 if (!negotiated) {
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930652 astlpc_prerr(astlpc, "Cannot negotiate with invalid versions");
653 return -EINVAL;
654 }
655
Andrew Jeffery88412be2021-03-09 22:05:22 +1030656 /* Assign protocol ops so we can calculate the packet buffer sizes */
657 assert(negotiated < ARRAY_SIZE(astlpc_protocol_version));
658 astlpc->proto = &astlpc_protocol_version[negotiated];
659
660 /* Negotiate packet buffers in v2 style if the BMC supports it */
661 if (negotiated >= 2) {
Andrew Jeffery3a540662020-05-26 19:55:30 +0930662 rc = mctp_astlpc_negotiate_layout_host(astlpc);
663 if (rc < 0)
664 return rc;
665 }
666
Andrew Jeffery88412be2021-03-09 22:05:22 +1030667 /* Advertise the host's supported protocol versions */
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930668 mctp_astlpc_lpc_write(astlpc, &ver_min_be,
669 offsetof(struct mctp_lpcmap_hdr, host_ver_min),
670 sizeof(ver_min_be));
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930671
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930672 mctp_astlpc_lpc_write(astlpc, &ver_cur_be,
673 offsetof(struct mctp_lpcmap_hdr, host_ver_cur),
674 sizeof(ver_cur_be));
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930675
676 /* Send channel init command */
Andrew Jefferyf13cb972020-05-28 09:30:09 +0930677 rc = mctp_astlpc_kcs_write(astlpc, MCTP_ASTLPC_KCS_REG_DATA, 0x0);
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930678 if (rc) {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +0930679 astlpc_prwarn(astlpc, "KCS write failed");
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930680 }
681
Andrew Jeffery88412be2021-03-09 22:05:22 +1030682 /*
683 * Configure the host so `astlpc->proto->version == 0` holds until we
684 * receive a subsequent status update from the BMC. Until then,
685 * `astlpc->proto->version == 0` indicates that we're yet to complete
686 * the channel initialisation handshake.
687 *
688 * When the BMC provides a status update with KCS_STATUS_CHANNEL_ACTIVE
689 * set we will assign the appropriate protocol ops struct in accordance
690 * with `negotiated_ver`.
691 */
692 astlpc->proto = &astlpc_protocol_version[ASTLPC_VER_BAD];
693
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930694 return rc;
695}
696
697static int mctp_binding_astlpc_start_host(struct mctp_binding *b)
698{
699 struct mctp_binding_astlpc *astlpc =
700 container_of(b, struct mctp_binding_astlpc, binding);
701
702 return mctp_astlpc_init_host(astlpc);
703}
704
705static bool __mctp_astlpc_kcs_ready(struct mctp_binding_astlpc *astlpc,
706 uint8_t status, bool is_write)
707{
708 bool is_bmc;
709 bool ready_state;
710 uint8_t flag;
711
712 is_bmc = (astlpc->mode == MCTP_BINDING_ASTLPC_MODE_BMC);
713 flag = (is_bmc ^ is_write) ? KCS_STATUS_IBF : KCS_STATUS_OBF;
714 ready_state = is_write ? 0 : 1;
715
716 return !!(status & flag) == ready_state;
717}
718
719static inline bool
720mctp_astlpc_kcs_read_ready(struct mctp_binding_astlpc *astlpc, uint8_t status)
721{
722 return __mctp_astlpc_kcs_ready(astlpc, status, false);
723}
724
725static inline bool
726mctp_astlpc_kcs_write_ready(struct mctp_binding_astlpc *astlpc, uint8_t status)
727{
728 return __mctp_astlpc_kcs_ready(astlpc, status, true);
729}
730
Jeremy Kerr672c8852019-03-01 12:18:07 +0800731static int mctp_astlpc_kcs_send(struct mctp_binding_astlpc *astlpc,
732 uint8_t data)
733{
734 uint8_t status;
735 int rc;
736
737 for (;;) {
Andrew Jefferyf13cb972020-05-28 09:30:09 +0930738 rc = mctp_astlpc_kcs_read(astlpc, MCTP_ASTLPC_KCS_REG_STATUS,
739 &status);
Andrew Jeffery1b27fe82020-01-24 16:05:11 +1030740 if (rc) {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +0930741 astlpc_prwarn(astlpc, "KCS status read failed");
Jeremy Kerr672c8852019-03-01 12:18:07 +0800742 return -1;
743 }
Andrew Jeffery7cd72f12020-05-12 20:27:59 +0930744 if (mctp_astlpc_kcs_write_ready(astlpc, status))
Jeremy Kerr672c8852019-03-01 12:18:07 +0800745 break;
746 /* todo: timeout */
747 }
748
Andrew Jefferyf13cb972020-05-28 09:30:09 +0930749 rc = mctp_astlpc_kcs_write(astlpc, MCTP_ASTLPC_KCS_REG_DATA, data);
Jeremy Kerrbc53d352019-08-28 14:26:14 +0530750 if (rc) {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +0930751 astlpc_prwarn(astlpc, "KCS data write failed");
Jeremy Kerr672c8852019-03-01 12:18:07 +0800752 return -1;
753 }
754
755 return 0;
756}
757
758static int mctp_binding_astlpc_tx(struct mctp_binding *b,
759 struct mctp_pktbuf *pkt)
760{
761 struct mctp_binding_astlpc *astlpc = binding_to_astlpc(b);
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930762 uint32_t len, len_be;
Andrew Jefferyedfe3832020-02-06 11:52:11 +1030763 struct mctp_hdr *hdr;
Jeremy Kerr672c8852019-03-01 12:18:07 +0800764
Andrew Jefferyedfe3832020-02-06 11:52:11 +1030765 hdr = mctp_pktbuf_hdr(pkt);
Jeremy Kerr672c8852019-03-01 12:18:07 +0800766 len = mctp_pktbuf_size(pkt);
Andrew Jefferyedfe3832020-02-06 11:52:11 +1030767
Andrew Jeffery9101a2a2020-05-22 16:08:03 +0930768 astlpc_prdebug(astlpc,
769 "%s: Transmitting %" PRIu32
770 "-byte packet (%hhu, %hhu, 0x%hhx)",
771 __func__, len, hdr->src, hdr->dest, hdr->flags_seq_tag);
Andrew Jefferyedfe3832020-02-06 11:52:11 +1030772
Andrew Jeffery88412be2021-03-09 22:05:22 +1030773 if (len > astlpc->proto->body_size(astlpc->layout.tx.size)) {
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030774 astlpc_prwarn(astlpc, "invalid TX len %" PRIu32 ": %" PRIu32, len,
775 astlpc->proto->body_size(astlpc->layout.tx.size));
Jeremy Kerr672c8852019-03-01 12:18:07 +0800776 return -1;
777 }
778
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930779 len_be = htobe32(len);
780 mctp_astlpc_lpc_write(astlpc, &len_be, astlpc->layout.tx.offset,
781 sizeof(len_be));
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030782
783 astlpc->proto->pktbuf_protect(pkt);
784 len = mctp_pktbuf_size(pkt);
785
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930786 mctp_astlpc_lpc_write(astlpc, hdr, astlpc->layout.tx.offset + 4, len);
Jeremy Kerr672c8852019-03-01 12:18:07 +0800787
788 mctp_binding_set_tx_enabled(b, false);
789
790 mctp_astlpc_kcs_send(astlpc, 0x1);
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030791
Jeremy Kerr672c8852019-03-01 12:18:07 +0800792 return 0;
793}
794
Andrew Jeffery3a540662020-05-26 19:55:30 +0930795static uint32_t mctp_astlpc_calculate_mtu(struct mctp_binding_astlpc *astlpc,
796 struct mctp_astlpc_layout *layout)
797{
Andrew Jeffery88412be2021-03-09 22:05:22 +1030798 uint32_t low, high, limit, rpkt;
Andrew Jeffery3a540662020-05-26 19:55:30 +0930799
800 /* Derive the largest MTU the BMC _can_ support */
801 low = MIN(astlpc->layout.rx.offset, astlpc->layout.tx.offset);
802 high = MAX(astlpc->layout.rx.offset, astlpc->layout.tx.offset);
803 limit = high - low;
804
Andrew Jefferya9368982020-06-09 13:07:39 +0930805 /* Determine the largest MTU the BMC _wants_ to support */
806 if (astlpc->requested_mtu) {
Andrew Jeffery88412be2021-03-09 22:05:22 +1030807 uint32_t rmtu = astlpc->requested_mtu;
Andrew Jefferya9368982020-06-09 13:07:39 +0930808
Andrew Jeffery88412be2021-03-09 22:05:22 +1030809 rpkt = astlpc->proto->packet_size(MCTP_PACKET_SIZE(rmtu));
810 limit = MIN(limit, rpkt);
Andrew Jefferya9368982020-06-09 13:07:39 +0930811 }
Andrew Jeffery3a540662020-05-26 19:55:30 +0930812
813 /* Determine the accepted MTU, applied both directions by convention */
Andrew Jeffery88412be2021-03-09 22:05:22 +1030814 rpkt = MIN(limit, layout->tx.size);
815 return MCTP_BODY_SIZE(astlpc->proto->body_size(rpkt));
Andrew Jeffery3a540662020-05-26 19:55:30 +0930816}
817
Andrew Jeffery88412be2021-03-09 22:05:22 +1030818static int mctp_astlpc_negotiate_layout_bmc(struct mctp_binding_astlpc *astlpc)
Andrew Jeffery3a540662020-05-26 19:55:30 +0930819{
820 struct mctp_astlpc_layout proposed, pending;
821 uint32_t sz, mtu;
822 int rc;
823
Andrew Jeffery88412be2021-03-09 22:05:22 +1030824 /* Do we have a valid protocol version? */
825 if (!astlpc->proto->version)
826 return -EINVAL;
827
Andrew Jeffery3a540662020-05-26 19:55:30 +0930828 /* Extract the host's proposed layout */
829 rc = mctp_astlpc_layout_read(astlpc, &proposed);
830 if (rc < 0)
831 return rc;
832
Andrew Jeffery88412be2021-03-09 22:05:22 +1030833 /* Do we have a reasonable layout? */
834 if (!mctp_astlpc_layout_validate(astlpc, &proposed))
Andrew Jeffery3a540662020-05-26 19:55:30 +0930835 return -EINVAL;
836
837 /* Negotiate the MTU */
838 mtu = mctp_astlpc_calculate_mtu(astlpc, &proposed);
Andrew Jeffery88412be2021-03-09 22:05:22 +1030839 sz = astlpc->proto->packet_size(MCTP_PACKET_SIZE(mtu));
Andrew Jeffery3a540662020-05-26 19:55:30 +0930840
841 /*
842 * Use symmetric MTUs by convention and to pass constraints in rx/tx
843 * functions
844 */
845 pending = astlpc->layout;
846 pending.tx.size = sz;
847 pending.rx.size = sz;
848
Andrew Jeffery88412be2021-03-09 22:05:22 +1030849 if (mctp_astlpc_layout_validate(astlpc, &pending)) {
Andrew Jeffery3a540662020-05-26 19:55:30 +0930850 /* We found a sensible Rx MTU, so honour it */
851 astlpc->layout = pending;
852
853 /* Enforce the negotiated MTU */
854 rc = mctp_astlpc_layout_write(astlpc, &astlpc->layout);
855 if (rc < 0)
856 return rc;
857
858 astlpc_prinfo(astlpc, "Negotiated an MTU of %" PRIu32 " bytes",
859 mtu);
860 } else {
861 astlpc_prwarn(astlpc, "MTU negotiation failed");
862 return -EINVAL;
863 }
864
Andrew Jeffery88412be2021-03-09 22:05:22 +1030865 if (astlpc->proto->version >= 2)
Andrew Jeffery3a540662020-05-26 19:55:30 +0930866 astlpc->binding.pkt_size = MCTP_PACKET_SIZE(mtu);
867
868 return 0;
869}
870
Jeremy Kerr672c8852019-03-01 12:18:07 +0800871static void mctp_astlpc_init_channel(struct mctp_binding_astlpc *astlpc)
872{
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930873 uint16_t negotiated, negotiated_be;
874 struct mctp_lpcmap_hdr hdr;
875 uint8_t status;
Andrew Jeffery3a540662020-05-26 19:55:30 +0930876 int rc;
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930877
878 mctp_astlpc_lpc_read(astlpc, &hdr, 0, sizeof(hdr));
879
880 /* Version negotiation */
881 negotiated =
882 mctp_astlpc_negotiate_version(ASTLPC_VER_MIN, ASTLPC_VER_CUR,
883 be16toh(hdr.host_ver_min),
884 be16toh(hdr.host_ver_cur));
885
Andrew Jeffery88412be2021-03-09 22:05:22 +1030886 /* MTU negotiation requires knowing which protocol we'll use */
887 assert(negotiated < ARRAY_SIZE(astlpc_protocol_version));
888 astlpc->proto = &astlpc_protocol_version[negotiated];
889
Andrew Jeffery3a540662020-05-26 19:55:30 +0930890 /* Host Rx MTU negotiation: Failure terminates channel init */
Andrew Jeffery88412be2021-03-09 22:05:22 +1030891 rc = mctp_astlpc_negotiate_layout_bmc(astlpc);
Andrew Jeffery3a540662020-05-26 19:55:30 +0930892 if (rc < 0)
893 negotiated = ASTLPC_VER_BAD;
894
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930895 /* Populate the negotiated version */
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930896 negotiated_be = htobe16(negotiated);
897 mctp_astlpc_lpc_write(astlpc, &negotiated_be,
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930898 offsetof(struct mctp_lpcmap_hdr, negotiated_ver),
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930899 sizeof(negotiated_be));
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930900
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930901 /* Finalise the configuration */
902 status = KCS_STATUS_BMC_READY | KCS_STATUS_OBF;
903 if (negotiated > 0) {
904 astlpc_prinfo(astlpc, "Negotiated binding version %" PRIu16,
905 negotiated);
906 status |= KCS_STATUS_CHANNEL_ACTIVE;
907 } else {
Andrew Jeffery88412be2021-03-09 22:05:22 +1030908 astlpc_prerr(astlpc, "Failed to initialise channel");
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930909 }
Jeremy Kerr672c8852019-03-01 12:18:07 +0800910
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930911 mctp_astlpc_kcs_set_status(astlpc, status);
912
913 mctp_binding_set_tx_enabled(&astlpc->binding,
914 status & KCS_STATUS_CHANNEL_ACTIVE);
Jeremy Kerr672c8852019-03-01 12:18:07 +0800915}
916
917static void mctp_astlpc_rx_start(struct mctp_binding_astlpc *astlpc)
918{
919 struct mctp_pktbuf *pkt;
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030920 uint32_t body, packet;
Jeremy Kerr672c8852019-03-01 12:18:07 +0800921
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030922 mctp_astlpc_lpc_read(astlpc, &body, astlpc->layout.rx.offset,
923 sizeof(body));
924 body = be32toh(body);
Jeremy Kerrbc53d352019-08-28 14:26:14 +0530925
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030926 if (body > astlpc->proto->body_size(astlpc->layout.rx.size)) {
927 astlpc_prwarn(astlpc, "invalid RX len 0x%x", body);
Jeremy Kerr672c8852019-03-01 12:18:07 +0800928 return;
929 }
930
Andrew Jefferyb93b6112020-06-05 14:13:44 +0930931 assert(astlpc->binding.pkt_size >= 0);
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030932 if (body > (uint32_t)astlpc->binding.pkt_size) {
933 astlpc_prwarn(astlpc, "invalid RX len 0x%x", body);
Jeremy Kerr672c8852019-03-01 12:18:07 +0800934 return;
935 }
936
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030937 /* Eliminate the medium-specific header that we just read */
938 packet = astlpc->proto->packet_size(body) - 4;
939 pkt = mctp_pktbuf_alloc(&astlpc->binding, packet);
Jeremy Kerr672c8852019-03-01 12:18:07 +0800940 if (!pkt)
941 goto out_complete;
942
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030943 /*
944 * Read payload and medium-specific trailer from immediately after the
945 * medium-specific header.
946 */
Andrew Jeffery55fb90b2020-05-12 13:54:37 +0930947 mctp_astlpc_lpc_read(astlpc, mctp_pktbuf_hdr(pkt),
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030948 astlpc->layout.rx.offset + 4, packet);
Jeremy Kerr672c8852019-03-01 12:18:07 +0800949
Andrew Jefferyeba19a32021-03-09 23:09:40 +1030950 /*
951 * v3 will validate the CRC32 in the medium-specific trailer and adjust
952 * the packet size accordingly. On older protocols validation is a no-op
953 * that always returns true.
954 */
955 if (astlpc->proto->pktbuf_validate(pkt)) {
956 mctp_bus_rx(&astlpc->binding, pkt);
957 } else {
958 /* TODO: Drop any associated assembly */
959 mctp_pktbuf_free(pkt);
960 astlpc_prdebug(astlpc, "Dropped corrupt packet");
961 }
Jeremy Kerr672c8852019-03-01 12:18:07 +0800962
963out_complete:
964 mctp_astlpc_kcs_send(astlpc, 0x2);
965}
966
967static void mctp_astlpc_tx_complete(struct mctp_binding_astlpc *astlpc)
968{
969 mctp_binding_set_tx_enabled(&astlpc->binding, true);
970}
971
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930972static int mctp_astlpc_finalise_channel(struct mctp_binding_astlpc *astlpc)
973{
Andrew Jeffery3a540662020-05-26 19:55:30 +0930974 struct mctp_astlpc_layout layout;
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930975 uint16_t negotiated;
976 int rc;
977
978 rc = mctp_astlpc_lpc_read(astlpc, &negotiated,
979 offsetof(struct mctp_lpcmap_hdr,
980 negotiated_ver),
981 sizeof(negotiated));
982 if (rc < 0)
983 return rc;
984
985 negotiated = be16toh(negotiated);
Andrew Jeffery88412be2021-03-09 22:05:22 +1030986 astlpc_prerr(astlpc, "Version negotiation got: %u", negotiated);
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930987
988 if (negotiated == ASTLPC_VER_BAD || negotiated < ASTLPC_VER_MIN ||
989 negotiated > ASTLPC_VER_CUR) {
990 astlpc_prerr(astlpc, "Failed to negotiate version, got: %u\n",
991 negotiated);
992 return -EINVAL;
993 }
994
Andrew Jeffery88412be2021-03-09 22:05:22 +1030995 assert(negotiated < ARRAY_SIZE(astlpc_protocol_version));
996 astlpc->proto = &astlpc_protocol_version[negotiated];
Andrew Jeffery4e8264b2020-05-23 20:34:33 +0930997
Andrew Jeffery3a540662020-05-26 19:55:30 +0930998 rc = mctp_astlpc_layout_read(astlpc, &layout);
999 if (rc < 0)
1000 return rc;
1001
Andrew Jeffery88412be2021-03-09 22:05:22 +10301002 if (!mctp_astlpc_layout_validate(astlpc, &layout)) {
Andrew Jeffery3a540662020-05-26 19:55:30 +09301003 mctp_prerr("BMC proposed invalid buffer parameters");
1004 return -EINVAL;
1005 }
1006
1007 astlpc->layout = layout;
1008
1009 if (negotiated >= 2)
1010 astlpc->binding.pkt_size =
Andrew Jeffery88412be2021-03-09 22:05:22 +10301011 astlpc->proto->body_size(astlpc->layout.tx.size);
Andrew Jeffery3a540662020-05-26 19:55:30 +09301012
Andrew Jeffery4e8264b2020-05-23 20:34:33 +09301013 return 0;
1014}
1015
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301016static int mctp_astlpc_update_channel(struct mctp_binding_astlpc *astlpc,
1017 uint8_t status)
1018{
1019 uint8_t updated;
1020 int rc = 0;
1021
1022 assert(astlpc->mode == MCTP_BINDING_ASTLPC_MODE_HOST);
1023
1024 updated = astlpc->kcs_status ^ status;
1025
Andrew Jefferyd0f5da02020-05-28 09:12:55 +09301026 astlpc_prdebug(astlpc, "%s: status: 0x%x, update: 0x%x", __func__,
1027 status, updated);
1028
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301029 if (updated & KCS_STATUS_BMC_READY) {
Andrew Jefferyd0f5da02020-05-28 09:12:55 +09301030 if (status & KCS_STATUS_BMC_READY) {
1031 astlpc->kcs_status = status;
1032 return astlpc->binding.start(&astlpc->binding);
1033 } else {
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301034 mctp_binding_set_tx_enabled(&astlpc->binding, false);
Andrew Jefferyd0f5da02020-05-28 09:12:55 +09301035 }
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301036 }
1037
Andrew Jeffery88412be2021-03-09 22:05:22 +10301038 if (astlpc->proto->version == 0 ||
1039 updated & KCS_STATUS_CHANNEL_ACTIVE) {
Andrew Jeffery4e8264b2020-05-23 20:34:33 +09301040 bool enable;
1041
1042 rc = mctp_astlpc_finalise_channel(astlpc);
1043 enable = (status & KCS_STATUS_CHANNEL_ACTIVE) && rc == 0;
1044
1045 mctp_binding_set_tx_enabled(&astlpc->binding, enable);
1046 }
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301047
1048 astlpc->kcs_status = status;
1049
1050 return rc;
1051}
1052
Jeremy Kerr672c8852019-03-01 12:18:07 +08001053int mctp_astlpc_poll(struct mctp_binding_astlpc *astlpc)
1054{
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301055 uint8_t status, data;
Jeremy Kerr672c8852019-03-01 12:18:07 +08001056 int rc;
1057
Andrew Jefferyf13cb972020-05-28 09:30:09 +09301058 rc = mctp_astlpc_kcs_read(astlpc, MCTP_ASTLPC_KCS_REG_STATUS, &status);
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301059 if (rc) {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301060 astlpc_prwarn(astlpc, "KCS read error");
Jeremy Kerr672c8852019-03-01 12:18:07 +08001061 return -1;
Jeremy Kerr672c8852019-03-01 12:18:07 +08001062 }
1063
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301064 astlpc_prdebug(astlpc, "%s: status: 0x%hhx", __func__, status);
Andrew Jefferyedfe3832020-02-06 11:52:11 +10301065
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301066 if (!mctp_astlpc_kcs_read_ready(astlpc, status))
Jeremy Kerr672c8852019-03-01 12:18:07 +08001067 return 0;
1068
Andrew Jefferyf13cb972020-05-28 09:30:09 +09301069 rc = mctp_astlpc_kcs_read(astlpc, MCTP_ASTLPC_KCS_REG_DATA, &data);
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301070 if (rc) {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301071 astlpc_prwarn(astlpc, "KCS data read error");
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301072 return -1;
1073 }
1074
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301075 astlpc_prdebug(astlpc, "%s: data: 0x%hhx", __func__, data);
Andrew Jefferyedfe3832020-02-06 11:52:11 +10301076
Andrew Jeffery88412be2021-03-09 22:05:22 +10301077 if (!astlpc->proto->version && !(data == 0x0 || data == 0xff)) {
Andrew Jefferyafcb7012021-01-28 17:00:36 +10301078 astlpc_prwarn(astlpc, "Invalid message for binding state: 0x%x",
1079 data);
1080 return 0;
1081 }
1082
Jeremy Kerr672c8852019-03-01 12:18:07 +08001083 switch (data) {
1084 case 0x0:
1085 mctp_astlpc_init_channel(astlpc);
1086 break;
1087 case 0x1:
1088 mctp_astlpc_rx_start(astlpc);
1089 break;
1090 case 0x2:
1091 mctp_astlpc_tx_complete(astlpc);
1092 break;
Jeremy Kerr1a4b55a2019-06-24 14:22:39 +08001093 case 0xff:
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301094 /* No responsibilities for the BMC on 0xff */
Andrew Jefferyd0f5da02020-05-28 09:12:55 +09301095 if (astlpc->mode == MCTP_BINDING_ASTLPC_MODE_HOST) {
1096 rc = mctp_astlpc_update_channel(astlpc, status);
1097 if (rc < 0)
1098 return rc;
1099 }
1100 break;
Jeremy Kerr672c8852019-03-01 12:18:07 +08001101 default:
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301102 astlpc_prwarn(astlpc, "unknown message 0x%x", data);
Jeremy Kerr672c8852019-03-01 12:18:07 +08001103 }
Andrew Jefferyd0f5da02020-05-28 09:12:55 +09301104
1105 /* Handle silent loss of bmc-ready */
1106 if (astlpc->mode == MCTP_BINDING_ASTLPC_MODE_HOST) {
1107 if (!(status & KCS_STATUS_BMC_READY && data == 0xff))
1108 return mctp_astlpc_update_channel(astlpc, status);
1109 }
1110
1111 return rc;
Jeremy Kerr672c8852019-03-01 12:18:07 +08001112}
1113
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301114/* allocate and basic initialisation */
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301115static struct mctp_binding_astlpc *__mctp_astlpc_init(uint8_t mode,
1116 uint32_t mtu)
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301117{
1118 struct mctp_binding_astlpc *astlpc;
1119
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301120 assert((mode == MCTP_BINDING_ASTLPC_MODE_BMC) ||
1121 (mode == MCTP_BINDING_ASTLPC_MODE_HOST));
1122
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301123 astlpc = __mctp_alloc(sizeof(*astlpc));
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301124 if (!astlpc)
1125 return NULL;
1126
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301127 memset(astlpc, 0, sizeof(*astlpc));
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301128 astlpc->mode = mode;
1129 astlpc->lpc_map = NULL;
Andrew Jefferya9368982020-06-09 13:07:39 +09301130 astlpc->requested_mtu = mtu;
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301131 astlpc->binding.name = "astlpc";
1132 astlpc->binding.version = 1;
Andrew Jeffery1a4f4412021-01-28 13:42:02 +10301133 astlpc->binding.pkt_size =
1134 MCTP_PACKET_SIZE(mtu > MCTP_BTU ? mtu : MCTP_BTU);
Andrew Jefferyeba19a32021-03-09 23:09:40 +10301135 astlpc->binding.pkt_header = 4;
1136 astlpc->binding.pkt_trailer = 4;
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301137 astlpc->binding.tx = mctp_binding_astlpc_tx;
1138 if (mode == MCTP_BINDING_ASTLPC_MODE_BMC)
1139 astlpc->binding.start = mctp_binding_astlpc_start_bmc;
1140 else if (mode == MCTP_BINDING_ASTLPC_MODE_HOST)
1141 astlpc->binding.start = mctp_binding_astlpc_start_host;
1142 else {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301143 astlpc_prerr(astlpc, "%s: Invalid mode: %d\n", __func__, mode);
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301144 __mctp_free(astlpc);
1145 return NULL;
1146 }
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301147
1148 return astlpc;
1149}
1150
Jeremy Kerr3b36d172019-09-04 11:56:09 +08001151struct mctp_binding *mctp_binding_astlpc_core(struct mctp_binding_astlpc *b)
1152{
1153 return &b->binding;
1154}
1155
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301156struct mctp_binding_astlpc *
1157mctp_astlpc_init(uint8_t mode, uint32_t mtu, void *lpc_map,
1158 const struct mctp_binding_astlpc_ops *ops, void *ops_data)
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301159{
1160 struct mctp_binding_astlpc *astlpc;
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301161
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301162 if (!(mode == MCTP_BINDING_ASTLPC_MODE_BMC ||
1163 mode == MCTP_BINDING_ASTLPC_MODE_HOST)) {
1164 mctp_prerr("Unknown binding mode: %u", mode);
1165 return NULL;
1166 }
1167
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301168 astlpc = __mctp_astlpc_init(mode, mtu);
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301169 if (!astlpc)
1170 return NULL;
1171
1172 memcpy(&astlpc->ops, ops, sizeof(astlpc->ops));
1173 astlpc->ops_data = ops_data;
1174 astlpc->lpc_map = lpc_map;
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301175 astlpc->mode = mode;
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301176
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301177 return astlpc;
1178}
1179
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301180struct mctp_binding_astlpc *
1181mctp_astlpc_init_ops(const struct mctp_binding_astlpc_ops *ops, void *ops_data,
1182 void *lpc_map)
1183{
1184 return mctp_astlpc_init(MCTP_BINDING_ASTLPC_MODE_BMC, MCTP_BTU, lpc_map,
1185 ops, ops_data);
1186}
1187
Andrew Jeffery4663f672020-03-10 23:36:24 +10301188void mctp_astlpc_destroy(struct mctp_binding_astlpc *astlpc)
1189{
Andrew Jefferyd0f5da02020-05-28 09:12:55 +09301190 /* Clear channel-active and bmc-ready */
1191 if (astlpc->mode == MCTP_BINDING_ASTLPC_MODE_BMC)
1192 mctp_astlpc_kcs_set_status(astlpc, KCS_STATUS_OBF);
Andrew Jeffery4663f672020-03-10 23:36:24 +10301193 __mctp_free(astlpc);
1194}
1195
Jeremy Kerrb214c642019-11-27 11:34:00 +08001196#ifdef MCTP_HAVE_FILEIO
Andrew Jeffery55fb90b2020-05-12 13:54:37 +09301197
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301198static int mctp_astlpc_init_fileio_lpc(struct mctp_binding_astlpc *astlpc)
Jeremy Kerr672c8852019-03-01 12:18:07 +08001199{
1200 struct aspeed_lpc_ctrl_mapping map = {
1201 .window_type = ASPEED_LPC_CTRL_WINDOW_MEMORY,
1202 .window_id = 0, /* There's only one */
1203 .flags = 0,
1204 .addr = 0,
1205 .offset = 0,
1206 .size = 0
1207 };
Andrew Jeffery979c6a12020-05-23 20:04:49 +09301208 void *lpc_map_base;
Jeremy Kerr672c8852019-03-01 12:18:07 +08001209 int fd, rc;
1210
1211 fd = open(lpc_path, O_RDWR | O_SYNC);
1212 if (fd < 0) {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301213 astlpc_prwarn(astlpc, "LPC open (%s) failed", lpc_path);
Jeremy Kerr672c8852019-03-01 12:18:07 +08001214 return -1;
1215 }
1216
1217 rc = ioctl(fd, ASPEED_LPC_CTRL_IOCTL_GET_SIZE, &map);
1218 if (rc) {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301219 astlpc_prwarn(astlpc, "LPC GET_SIZE failed");
Jeremy Kerr672c8852019-03-01 12:18:07 +08001220 close(fd);
1221 return -1;
1222 }
1223
Andrew Jeffery979c6a12020-05-23 20:04:49 +09301224 lpc_map_base =
1225 mmap(NULL, map.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1226 if (lpc_map_base == MAP_FAILED) {
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301227 astlpc_prwarn(astlpc, "LPC mmap failed");
Jeremy Kerr672c8852019-03-01 12:18:07 +08001228 rc = -1;
1229 } else {
Andrew Jeffery979c6a12020-05-23 20:04:49 +09301230 astlpc->lpc_map = lpc_map_base + map.size - LPC_WIN_SIZE;
Jeremy Kerr672c8852019-03-01 12:18:07 +08001231 }
1232
1233 close(fd);
1234
1235 return rc;
1236}
1237
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301238static int mctp_astlpc_init_fileio_kcs(struct mctp_binding_astlpc *astlpc)
Jeremy Kerr672c8852019-03-01 12:18:07 +08001239{
1240 astlpc->kcs_fd = open(kcs_path, O_RDWR);
1241 if (astlpc->kcs_fd < 0)
1242 return -1;
1243
1244 return 0;
1245}
1246
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301247static int __mctp_astlpc_fileio_kcs_read(void *arg,
1248 enum mctp_binding_astlpc_kcs_reg reg, uint8_t *val)
1249{
1250 struct mctp_binding_astlpc *astlpc = arg;
1251 off_t offset = reg;
1252 int rc;
1253
1254 rc = pread(astlpc->kcs_fd, val, 1, offset);
1255
1256 return rc == 1 ? 0 : -1;
1257}
1258
1259static int __mctp_astlpc_fileio_kcs_write(void *arg,
1260 enum mctp_binding_astlpc_kcs_reg reg, uint8_t val)
1261{
1262 struct mctp_binding_astlpc *astlpc = arg;
1263 off_t offset = reg;
1264 int rc;
1265
1266 rc = pwrite(astlpc->kcs_fd, &val, 1, offset);
1267
1268 return rc == 1 ? 0 : -1;
1269}
1270
1271int mctp_astlpc_get_fd(struct mctp_binding_astlpc *astlpc)
1272{
1273 return astlpc->kcs_fd;
1274}
1275
1276struct mctp_binding_astlpc *mctp_astlpc_init_fileio(void)
Jeremy Kerr672c8852019-03-01 12:18:07 +08001277{
1278 struct mctp_binding_astlpc *astlpc;
1279 int rc;
1280
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301281 /*
1282 * If we're doing file IO then we're very likely not running
Andrew Jeffery8877c462020-06-15 12:22:53 +09301283 * freestanding, so lets assume that we're on the BMC side.
1284 *
1285 * Requesting an MTU of 0 requests the largest possible MTU, whatever
1286 * value that might take.
Andrew Jeffery7cd72f12020-05-12 20:27:59 +09301287 */
Andrew Jeffery8877c462020-06-15 12:22:53 +09301288 astlpc = __mctp_astlpc_init(MCTP_BINDING_ASTLPC_MODE_BMC, 0);
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301289 if (!astlpc)
1290 return NULL;
Jeremy Kerr672c8852019-03-01 12:18:07 +08001291
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301292 /* Set internal operations for kcs. We use direct accesses to the lpc
1293 * map area */
1294 astlpc->ops.kcs_read = __mctp_astlpc_fileio_kcs_read;
1295 astlpc->ops.kcs_write = __mctp_astlpc_fileio_kcs_write;
1296 astlpc->ops_data = astlpc;
1297
1298 rc = mctp_astlpc_init_fileio_lpc(astlpc);
Jeremy Kerr672c8852019-03-01 12:18:07 +08001299 if (rc) {
1300 free(astlpc);
1301 return NULL;
1302 }
1303
Jeremy Kerrbc53d352019-08-28 14:26:14 +05301304 rc = mctp_astlpc_init_fileio_kcs(astlpc);
Jeremy Kerr672c8852019-03-01 12:18:07 +08001305 if (rc) {
1306 free(astlpc);
1307 return NULL;
1308 }
1309
Jeremy Kerr672c8852019-03-01 12:18:07 +08001310 return astlpc;
1311}
Jeremy Kerr92a10a62019-08-28 16:55:54 +05301312#else
1313struct mctp_binding_astlpc * __attribute__((const))
1314 mctp_astlpc_init_fileio(void)
1315{
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301316 astlpc_prerr(astlpc, "Missing support for file IO");
Jeremy Kerr92a10a62019-08-28 16:55:54 +05301317 return NULL;
1318}
Jeremy Kerr672c8852019-03-01 12:18:07 +08001319
Jeremy Kerr92a10a62019-08-28 16:55:54 +05301320int __attribute__((const)) mctp_astlpc_get_fd(
1321 struct mctp_binding_astlpc *astlpc __attribute__((unused)))
1322{
Andrew Jeffery9101a2a2020-05-22 16:08:03 +09301323 astlpc_prerr(astlpc, "Missing support for file IO");
Jeremy Kerr92a10a62019-08-28 16:55:54 +05301324 return -1;
1325}
1326#endif