cdnutter
/
iBoot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
iBoot/drivers/thunderbolt/tbt_control_port.c

625 lines
16 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) 2013 Apple Inc. All rights reserved.
*
* This document is the property of Apple Inc.
* It is considered confidential and proprietary.
*
* This document may not be reproduced or transmitted in any form,
* in whole or in part, without the express written permission of
* Apple Inc.
*/
#include <debug.h>
#include <drivers/thunderbolt/nhi.h>
#include <list.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/menu.h>
#include <sys/task.h>
#include "tbt_control_port.h"
#include "tbt_cp_crc.h"
#include "tbt_xdomain.h"
#include "tbt_protocol.h"
#define CPDBG_DUMP_PACKET DEBUG_NEVER
#define CPDBG_INIT DEBUG_INFO
#define CPDBG_IO DEBUG_SPEW
#define CPDBG_EVENT DEBUG_SPEW
struct xd_service {
struct list_node list;
// Callback function to handle incoming xdomain requests for this service
tbt_xd_callback_t request_callback;
// Callback function to handle incoming xdomain responses for this service
tbt_xd_callback_t response_callback;
// Private data passed in when the service was register
void *priv;
};
struct tbt_cp {
nhi_t *nhi;
uint8_t rx_buffer[256];
uint8_t tx_buffer[256];
uint8_t pdf_next_seq[TBT_CFG_MAX_PDF + 1];
bool shutdown;
struct task *polling_task;
struct list_node xd_services;
uint32_t *read_req_buffer;
uint32_t read_req_header;
uint16_t read_req_quads;
bool read_req_pending;
struct task_event read_event;
uint32_t write_req_header;
bool write_req_pending;
struct task_event write_event;
};
static void tbt_cp_process_xd_request(tbt_cp_t *cp, uint8_t *packet, size_t bytes);
static void tbt_cp_process_xd_response(tbt_cp_t *cp, uint8_t *packet, size_t bytes);
static void tbt_cp_process_read_response(tbt_cp_t *cp, uint8_t *packet, size_t bytes);
static void tbt_cp_process_write_response(tbt_cp_t *cp, uint8_t *packet, size_t bytes);
static void tbt_cp_process_plug_event(tbt_cp_t *cp, uint8_t *packet, size_t bytes);
static void tbt_cp_process_error(tbt_cp_t *cp, uint8_t *packet, size_t bytes);
static int tbt_cp_polling_task(void *arg);
static tbt_cp_t *g_tbt_cp;
void tbt_cp_dump_route_string(uint64_t route_string)
{
if (route_string & (1ULL << 63))
printf("CM:");
printf("%02x", route_string & 0x3F);
for (int i = 1; i < 7; i++) {
if (((route_string >> (i * 8)) & 0x3F) == 0)
break;
printf(",%02x", (route_string >> (i * 8)) & 0x3F);
}
}
uint64_t tbt_cp_packet_get_route_string(const uint8_t *packet)
{
uint64_t route_string = 0;
for (int i = 0; i < 8; i++)
route_string |= (uint64_t)packet[i] << ((8 - i - 1) * 8);
return route_string;
}
void tbt_cp_packet_set_route_string(uint8_t *packet, uint64_t route_string)
{
for (int i = 0; i < 8; i++)
packet[i] = route_string >> ((8 - i - 1) * 8);
}
void tbt_cp_dump_xdomain_message(uint8_t *packet, size_t bytes)
{
#if CPDBG_DUMP_PACKET <= DEBUG_LEVEL
uint64_t route = tbt_cp_packet_get_route_string(packet);
uint32_t header;
uint32_t seq;
uint32_t payload_len;
char *len_message = "";
size_t offset;
memcpy(&header, packet + 8, sizeof(uint32_t));
header = htonl(header);
seq = (header >> 27) & 0x3;
payload_len = header & 0x3f;
if (payload_len * 4 > bytes - 12)
len_message = " (INVALID)";
printf("Route String: ");
tbt_cp_dump_route_string(route);
printf("\n");
printf("Length: 0x%02x%s\n", payload_len, len_message);
printf("Sequence Num: 0x%02x\n", seq);
printf("Payload:\n");
if (payload_len * 4 > bytes - 12)
payload_len = (bytes - 12) / 4;
offset = 0;
while (offset < payload_len * 4) {
for (int i = 0; i < 16 && offset < payload_len * 4; i++, offset++)
printf("%02x ", packet[offset + 12]);
printf("\n");
}
#endif
}
void tbt_cp_dump_message(uint8_t *packet, size_t bytes)
{
#if CPDBG_DUMP_PACKET <= DEBUG_LEVEL
uint64_t route = tbt_cp_packet_get_route_string(packet);
uint32_t value;
printf("Route String: ");
tbt_cp_dump_route_string(route);
printf("\nPayload:\n");
for (size_t i = 0; i < bytes - 12; i += 4) {
memcpy(&value, packet + 8 + i, 4);
printf("%08x ", value);
if (i % 16 == 12)
printf("\n");
}
if ((bytes - 12) % 16 != 0)
printf("\n");
memcpy(&value, packet + bytes - 4, 4);
printf("CRC: %08x\n", value);
#endif
}
tbt_cp_t *tbt_cp_create(nhi_t *nhi)
{
tbt_cp_t *cp;
cp = calloc(sizeof(*cp), 1);
dprintf(CPDBG_INIT, "tbt_cp: initializing\n");
cp->nhi = nhi;
cp->xd_services = LIST_INITIAL_VALUE(cp->xd_services);
// Control messages are sent/received on ring 0
// 16 buffers should be plenty. The packets are 256 bytes each
// These functions will panic if someone already took the ring
nhi_init_tx_ring(nhi, 0, 16, 256);
nhi_init_rx_ring(nhi, 0, 16, 256);
event_init(&cp->read_event, EVENT_FLAG_AUTO_UNSIGNAL, false);
event_init(&cp->write_event, EVENT_FLAG_AUTO_UNSIGNAL, false);
// start a thread to handle packets for the control port
cp->polling_task = task_create("tbt_polling", tbt_cp_polling_task, cp, 0);
task_start(cp->polling_task);
// Pointer used for debug command access to the control port, assumes only 1 exists
g_tbt_cp = cp;
return cp;
}
void tbt_cp_quiesce_and_free(tbt_cp_t *cp)
{
cp->shutdown = true;
task_wait_on(cp->polling_task);
task_destroy(cp->polling_task);
cp->polling_task = NULL;
nhi_disable_tx_ring(cp->nhi, 0);
nhi_disable_rx_ring(cp->nhi, 0);
free(cp);
}
void *tbt_cp_register_xd_service(tbt_cp_t *cp, tbt_xd_callback_t req_cb, tbt_xd_callback_t resp_cb, void *priv)
{
struct xd_service *new_service;
ASSERT(req_cb != NULL);
ASSERT(resp_cb != NULL);
new_service = calloc(sizeof(*new_service), 1);
new_service->request_callback = req_cb;
new_service->response_callback = resp_cb;
new_service->priv = priv;
list_add_tail(&cp->xd_services, &new_service->list);
return (void *)&new_service->list;
}
void tbt_cp_unregister_xd_service(tbt_cp_t *cp, void *handle)
{
struct list_node *item = (struct list_node *)handle;
struct xd_service *service;
if (!list_in_list(item))
panic("unregistering nonregistered xdomain service");
service = containerof(item, struct xd_service, list);
list_delete(item);
free(service);
}
bool tbt_cp_packet_available(tbt_cp_t *cp)
{
ASSERT(cp != NULL);
return nhi_rx_buffer_available(cp->nhi, 0);
}
void tbt_cp_process_packet(tbt_cp_t *cp)
{
uint8_t eof_pdf;
int32_t bytes;
uint32_t packet_crc;
uint32_t calc_crc;
bytes = nhi_rx_buffer(cp->nhi, 0, cp->rx_buffer, sizeof(cp->rx_buffer), NULL, &eof_pdf);
if (bytes < 0) {
dprintf(DEBUG_CRITICAL, "tbt_cp: error %d receiving packet\n", bytes);
return;
}
// Packet must be big enough for header + CRC
if (bytes < TBT_CFG_HEADER_LEN + 4) {
dprintf(DEBUG_CRITICAL, "tbt_cp: runt packet\n");
return;
}
calc_crc = tbt_cp_crc(cp->rx_buffer, bytes - 4);
memcpy(&packet_crc, cp->rx_buffer + bytes - 4, 4);
packet_crc = ntohl(packet_crc);
if (calc_crc != packet_crc) {
dprintf(DEBUG_CRITICAL, "tbt_cp: CRC mismatch %x v %x\n", calc_crc, packet_crc);
return;
}
switch (eof_pdf) {
case TBT_CFG_READ_PDF:
tbt_cp_dump_message(cp->rx_buffer, bytes);
tbt_cp_process_read_response(cp, cp->rx_buffer, bytes - 4);
break;
case TBT_CFG_WRITE_PDF:
tbt_cp_dump_message(cp->rx_buffer, bytes);
tbt_cp_process_write_response(cp, cp->rx_buffer, bytes - 4);
break;
case TBT_CFG_PLUG_EVENT_PDF:
tbt_cp_process_plug_event(cp, cp->rx_buffer, bytes - 4);
break;
case TBT_CFG_ERROR_PDF:
tbt_cp_dump_message(cp->rx_buffer, bytes);
tbt_cp_process_error(cp, cp->rx_buffer, bytes - 4);
break;
case TBT_CFG_XDOMAIN_REQUEST_PDF:
tbt_cp_dump_xdomain_message(cp->rx_buffer, bytes);
tbt_cp_process_xd_request(cp, cp->rx_buffer, bytes - 4);
break;
case TBT_CFG_XDOMAIN_RESPONSE_PDF:
tbt_cp_dump_xdomain_message(cp->rx_buffer, bytes);
tbt_cp_process_xd_response(cp, cp->rx_buffer, bytes - 4);
break;
default:
dprintf(DEBUG_INFO, "tbt_cp: got unexpected PDF 0x%02x\n", eof_pdf);
tbt_cp_dump_message(cp->rx_buffer, bytes);
break;
}
}
// Control port packets have a 2-bit sequence number. The OS stack increments the
// sequence number per PDF, so we'll do the same. This function gets the next
// sequence number and increments a 2-bit counter to provide for the subsequent value
uint8_t tbt_cp_next_pdf_seq(tbt_cp_t *cp, uint8_t pdf)
{
uint8_t next;
ASSERT(cp != NULL);
ASSERT(pdf <= TBT_CFG_MAX_PDF);
next = cp->pdf_next_seq[pdf];
cp->pdf_next_seq[pdf] = (next + 1) & 3;
return next;
}
// Queues the given packet to be sent
bool tbt_cp_send(tbt_cp_t *cp, uint8_t pdf, uint8_t *packet, size_t len)
{
uint32_t crc;
nhi_sgl_t sgl[2];
ASSERT(len <= TBT_CFG_MAX_HEADER_AND_PAYLOAD);
crc = htonl(tbt_cp_crc(packet, len));
sgl[0].buffer = packet;
sgl[0].bytes = len;
sgl[0].next = &sgl[1];
sgl[1].buffer = &crc;
sgl[1].bytes = sizeof(crc);
sgl[1].next = NULL;
return nhi_send_sgl(cp->nhi, 0, sgl, pdf, pdf) == NHI_STATUS_OK;
}
void tbt_cp_send_acknowledgement(tbt_cp_t *cp, uint64_t route_string, uint8_t port, uint8_t code)
{
uint32_t packet[3];
packet[0] = route_string >> 32;
packet[1] = route_string;
packet[2] = htonl((port << 8) | code);
tbt_cp_send(cp, TBT_CFG_ERROR_PDF, (uint8_t *)packet, sizeof(packet));
}
bool tbt_cp_read(tbt_cp_t *cp, uint64_t topology_id, uint8_t space, uint8_t port, uint16_t index, uint32_t *buffer, uint16_t quadlets)
{
bool ret;
uint32_t request[3];
uint32_t header;
uint8_t pdf = TBT_CFG_READ_PDF;
uint8_t seq = tbt_cp_next_pdf_seq(cp, pdf);
ASSERT(quadlets < 60);
dprintf(CPDBG_IO, "tbt_cp: reading %d quads from %08llx %x:%02x:%04x\n", quadlets, topology_id, space, port, index);
request[0] = htonl(topology_id >> 32);
request[1] = htonl(topology_id & 0xffffffff);
header = 0;
header |= (index & 0x1fff) << 0;
header |= (quadlets & 0x3f) << 13;
header |= (port & 0x3f) << 19;
header |= (space & 0x3) << 25;
header |= seq << 27;
request[2] = htonl(header);
if (!tbt_cp_send(cp, pdf, (uint8_t *)request, sizeof(request)))
return false;
// If we ever switch to interrupts, this will need to be reconsidered
cp->read_req_header = header;
cp->read_req_buffer = buffer;
cp->read_req_quads = quadlets;
cp->read_req_pending = true;
event_wait_timeout(&cp->read_event, 200000);
// if the read request is no longer pending, then tbt_cp_process_read_response saw a good response
ret = !cp->read_req_pending;
cp->read_req_pending = false;
if (ret) {
for (unsigned i = 0; i < quadlets; i++)
buffer[i] = ntohl(buffer[i]);
}
return ret;
}
bool tbt_cp_write(tbt_cp_t *cp, uint64_t topology_id, uint8_t space, uint8_t port, uint16_t index, const uint32_t *buffer, uint16_t quadlets)
{
uint8_t pdf = TBT_CFG_WRITE_PDF;
uint8_t seq = tbt_cp_next_pdf_seq(cp, pdf);
uint32_t header;
uint32_t topo_high;
uint32_t topo_low;
uint32_t swapped;
bool ret;
dprintf(CPDBG_IO, "tbt_cp: write %d quads to %016llx %x:%02x:%04x\n", quadlets, topology_id, space, port, index);
ASSERT(quadlets < 60);
topo_high = htonl(topology_id >> 32);
topo_low = htonl(topology_id & 0xffffffff);
header = 0;
header |= (index & 0x1fff) << 0;
header |= (quadlets & 0x3f) << 13;
header |= (port & 0x3f) << 19;
header |= (space & 0x3) << 25;
header |= seq << 27;
header = htonl(header);
memcpy(cp->tx_buffer + 0, &topo_high, 4);
memcpy(cp->tx_buffer + 4, &topo_low, 4);
memcpy(cp->tx_buffer + 8, &header, 4);
for(uint16_t i = 0; i < quadlets; i++) {
swapped = htonl(buffer[i]);
memcpy(cp->tx_buffer + 12 + 4 * i, &swapped, 4);
}
if (!tbt_cp_send(cp, pdf, cp->tx_buffer, 12 + 4 * quadlets))
return false;
// If we ever use interrupts, this will need to be reordered compared to the send call
cp->write_req_header = ntohl(header);
cp->write_req_pending = true;
event_wait_timeout(&cp->write_event, 200000);
// If write_req_pending is false, then tbt_cp_process_write_response saw a good response
ret = !cp->write_req_pending;
cp->write_req_pending = false;
return true;
}
static void tbt_cp_process_read_response(tbt_cp_t *cp, uint8_t *packet, size_t bytes)
{
uint16_t len;
uint32_t header;
if (!cp->read_req_pending) {
dprintf(DEBUG_CRITICAL, "tbt_cp: spurious read request response\n");
return;
}
memcpy(&header, packet + 8, 4);
header = ntohl(header);
len = (header >> 13) & 0x3f;
dprintf(CPDBG_IO, "tbt_cp: read response header=0x%08x bytes=%u\n", header, (unsigned)bytes);
// The far end is supposed to just copy the entire header back to us. They seem
// to put garbage in the port number when we aren't reading port space, so
// ignore it in the comparison
if ((header & 0x1E07FFFF) != (cp->read_req_header & 0x1E07FFFF)) {
dprintf(DEBUG_CRITICAL, "tbt_cp: read request header mismatch, got %x expected %x mismatch %x\n", header, cp->read_req_header, header ^ cp->read_req_header);
return;
}
// Belt and suspenders check on the length, which is included in the header
if (len != cp->read_req_quads) {
dprintf(DEBUG_CRITICAL, "tbt_cp: read request len mismatch, got %u expected %u\n", len, cp->read_req_quads);
return;
}
if (bytes != (len * 4) + 12) {
dprintf(DEBUG_CRITICAL, "tbt_cp: read request payload len mismatch, got %u expected %u\n", bytes, (len * 4) + 16);
return;
}
memcpy(cp->read_req_buffer, packet + 12, cp->read_req_quads * 4);
cp->read_req_pending = false;
event_signal(&cp->read_event);
}
static void tbt_cp_process_write_response(tbt_cp_t *cp, uint8_t *packet, size_t bytes)
{
uint32_t header;
if (!cp->write_req_pending) {
dprintf(DEBUG_CRITICAL, "tbt_cp: spurious write request response\n");
return;
}
memcpy(&header, packet + 8, 4);
header = ntohl(header);
dprintf(CPDBG_IO, "tbt_cp: write response header=0x%08x bytes=%u\n", header, (unsigned)bytes);
// The far end is supposed to just copy the entire header back to us. We'll
// mask off the reserved bits, but otherwise everything had better match
if ((header & 0x1fffffff) != cp->write_req_header) {
dprintf(DEBUG_CRITICAL, "tbt_cp: write request header mismatch, got %x expected %x\n", header, cp->read_req_header);
return;
}
cp->write_req_pending = false;
event_signal(&cp->write_event);
}
static void tbt_cp_process_plug_event(tbt_cp_t *cp, uint8_t *packet, size_t bytes)
{
uint64_t route_string;
uint32_t details;
uint8_t port;
// Send the acknowledgement back to the sender, clearing the CM bit
route_string = tbt_cp_packet_get_route_string(packet);
route_string &= ~(1ULL << 63);
memcpy(&details, packet + 8, sizeof(details));
details = ntohl(details);
port = details & 0x3f;
dprintf(CPDBG_EVENT, "tbt_cp: Got plug event from %016llx for port %x\n", route_string, port);
tbt_cp_send_acknowledgement(cp, route_string, port, 7);
}
static void tbt_cp_process_error(tbt_cp_t *cp, uint8_t *packet, size_t bytes)
{
uint64_t route_string;
// XXX
dprintf(DEBUG_INFO, "Got an error packet. We should probably handle these?\n");
route_string = tbt_cp_packet_get_route_string(packet);
}
static void tbt_cp_process_xd_request(tbt_cp_t *cp, uint8_t *packet, size_t bytes)
{
struct xd_service *service;
list_for_every_entry(&cp->xd_services, service, struct xd_service, list) {
service->request_callback(cp, packet, bytes, service->priv);
}
}
static void tbt_cp_process_xd_response(tbt_cp_t *cp, uint8_t *packet, size_t bytes)
{
struct xd_service *service;
list_for_every_entry(&cp->xd_services, service, struct xd_service, list) {
service->response_callback(cp, packet, bytes, service->priv);
}
}
static int tbt_cp_polling_task(void *arg)
{
tbt_cp_t *cp = (tbt_cp_t *)arg;
dprintf(CPDBG_INIT, "tbt_cp: polling task started\n");
while (!cp->shutdown) {
while (tbt_cp_packet_available(cp)) {
tbt_cp_process_packet(cp);
}
task_yield();
}
dprintf(CPDBG_INIT, "tbt_cp: polling task finished\n");
return 0;
}
#if DEBUG_BUILD
static int do_tbtcp_debug_cmd(int argc, struct cmd_arg *args)
{
int result = -1;
const char *cmd = NULL;
// Nothing to do if there's no control port
if (g_tbt_cp == NULL)
return -1;
if (argc >= 2)
cmd = args[1].str;
if (cmd != NULL) {
if (strcmp(cmd, "read") == 0 && argc >= 6) {
uint64_t topo_id = args[2].n;
uint8_t space = args[3].n;
uint8_t port = args[4].n;
uint16_t index = args[5].n;
uint32_t buffer;
if (tbt_cp_read(g_tbt_cp, topo_id, space, port, index, &buffer, 1)) {
printf("0x%08x\n", buffer);
result = 0;
} else {
printf("read failure\n");
}
} else if (strcmp(cmd, "write") == 0 && argc >= 7) {
uint64_t topo_id = args[2].n;
uint8_t space = args[3].n;
uint8_t port = args[4].n;
uint16_t index = args[5].n;
uint32_t buffer = args[6].n;
if (tbt_cp_write(g_tbt_cp, topo_id, space, port, index, &buffer, 1)) {
result = 0;
} else {
printf("write failure\n");
}
}
}
return result;
}
#endif
MENU_COMMAND_DEBUG(tbtcp, do_tbtcp_debug_cmd, "TBT control port debug commands", NULL);
Reference in New Issue View Git Blame Copy Permalink