gb-beagleplay.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Beagleplay Linux Driver for Greybus
   4 *
   5 * Copyright (c) 2023 Ayush Singh <ayushdevel1325@gmail.com>
   6 * Copyright (c) 2023 BeagleBoard.org Foundation
   7 */
   8
   9#include <linux/unaligned.h>
  10#include <linux/crc32.h>
  11#include <linux/gpio/consumer.h>
  12#include <linux/firmware.h>
  13#include <linux/greybus.h>
  14#include <linux/serdev.h>
  15#include <linux/crc-ccitt.h>
  16#include <linux/circ_buf.h>
  17
  18#define CC1352_FIRMWARE_SIZE (704 * 1024)
  19#define CC1352_BOOTLOADER_TIMEOUT 2000
  20#define CC1352_BOOTLOADER_ACK 0xcc
  21#define CC1352_BOOTLOADER_NACK 0x33
  22
  23#define RX_HDLC_PAYLOAD 256
  24#define CRC_LEN 2
  25#define MAX_RX_HDLC (1 + RX_HDLC_PAYLOAD + CRC_LEN)
  26#define TX_CIRC_BUF_SIZE 1024
  27
  28#define ADDRESS_GREYBUS 0x01
  29#define ADDRESS_DBG 0x02
  30#define ADDRESS_CONTROL 0x03
  31
  32#define HDLC_FRAME 0x7E
  33#define HDLC_ESC 0x7D
  34#define HDLC_XOR 0x20
  35
  36#define CONTROL_SVC_START 0x01
  37#define CONTROL_SVC_STOP 0x02
  38
  39/* The maximum number of CPorts supported by Greybus Host Device */
  40#define GB_MAX_CPORTS 32
  41
  42/**
  43 * struct gb_beagleplay - BeaglePlay Greybus driver
  44 *
  45 * @sd: underlying serdev device
  46 *
  47 * @gb_hd: greybus host device
  48 *
  49 * @tx_work: hdlc transmit work
  50 * @tx_producer_lock: hdlc transmit data producer lock. acquired when appending data to buffer.
  51 * @tx_consumer_lock: hdlc transmit data consumer lock. acquired when sending data over uart.
  52 * @tx_circ_buf: hdlc transmit circular buffer.
  53 * @tx_crc: hdlc transmit crc-ccitt fcs
  54 *
  55 * @rx_buffer_len: length of receive buffer filled.
  56 * @rx_buffer: hdlc frame receive buffer
  57 * @rx_in_esc: hdlc rx flag to indicate ESC frame
  58 *
  59 * @fwl: underlying firmware upload device
  60 * @bootloader_backdoor_gpio: cc1352p7 boot gpio
  61 * @rst_gpio: cc1352p7 reset gpio
  62 * @flashing_mode: flag to indicate that flashing is currently in progress
  63 * @fwl_ack_com: completion to signal an Ack/Nack
  64 * @fwl_ack: Ack/Nack byte received
  65 * @fwl_cmd_response_com: completion to signal a bootloader command response
  66 * @fwl_cmd_response: bootloader command response data
  67 * @fwl_crc32: crc32 of firmware to flash
  68 * @fwl_reset_addr: flag to indicate if we need to send COMMAND_DOWNLOAD again
  69 */
  70struct gb_beagleplay {
  71	struct serdev_device *sd;
  72
  73	struct gb_host_device *gb_hd;
  74
  75	struct work_struct tx_work;
  76	spinlock_t tx_producer_lock;
  77	spinlock_t tx_consumer_lock;
  78	struct circ_buf tx_circ_buf;
  79	u16 tx_crc;
  80
  81	u16 rx_buffer_len;
  82	bool rx_in_esc;
  83	u8 rx_buffer[MAX_RX_HDLC];
  84
  85	struct fw_upload *fwl;
  86	struct gpio_desc *bootloader_backdoor_gpio;
  87	struct gpio_desc *rst_gpio;
  88	bool flashing_mode;
  89	struct completion fwl_ack_com;
  90	u8 fwl_ack;
  91	struct completion fwl_cmd_response_com;
  92	u32 fwl_cmd_response;
  93	u32 fwl_crc32;
  94	bool fwl_reset_addr;
  95};
  96
  97/**
  98 * struct hdlc_payload - Structure to represent part of HDCL frame payload data.
  99 *
 100 * @len: buffer length in bytes
 101 * @buf: payload buffer
 102 */
 103struct hdlc_payload {
 104	u16 len;
 105	void *buf;
 106};
 107
 108/**
 109 * struct hdlc_greybus_frame - Structure to represent greybus HDLC frame payload
 110 *
 111 * @cport: cport id
 112 * @hdr: greybus operation header
 113 * @payload: greybus message payload
 114 *
 115 * The HDLC payload sent over UART for greybus address has cport preappended to greybus message
 116 */
 117struct hdlc_greybus_frame {
 118	__le16 cport;
 119	struct gb_operation_msg_hdr hdr;
 120	u8 payload[];
 121} __packed;
 122
 123/**
 124 * enum cc1352_bootloader_cmd: CC1352 Bootloader Commands
 125 *
 126 * @COMMAND_DOWNLOAD: Prepares flash programming
 127 * @COMMAND_GET_STATUS: Returns the status of the last command that was  issued
 128 * @COMMAND_SEND_DATA: Transfers data and programs flash
 129 * @COMMAND_RESET: Performs a system reset
 130 * @COMMAND_CRC32: Calculates CRC32 over a specified memory area
 131 * @COMMAND_BANK_ERASE: Performs an erase of all of the customer-accessible
 132 *                      flash sectors not protected by FCFG1 and CCFG
 133 *                      writeprotect bits.
 134 *
 135 * CC1352 Bootloader serial bus commands
 136 */
 137enum cc1352_bootloader_cmd {
 138	COMMAND_DOWNLOAD = 0x21,
 139	COMMAND_GET_STATUS = 0x23,
 140	COMMAND_SEND_DATA = 0x24,
 141	COMMAND_RESET = 0x25,
 142	COMMAND_CRC32 = 0x27,
 143	COMMAND_BANK_ERASE = 0x2c,
 144};
 145
 146/**
 147 * enum cc1352_bootloader_status: CC1352 Bootloader COMMAND_GET_STATUS response
 148 *
 149 * @COMMAND_RET_SUCCESS: Status for successful command
 150 * @COMMAND_RET_UNKNOWN_CMD: Status for unknown command
 151 * @COMMAND_RET_INVALID_CMD: Status for invalid command (in other words,
 152 *                           incorrect packet size)
 153 * @COMMAND_RET_INVALID_ADR: Status for invalid input address
 154 * @COMMAND_RET_FLASH_FAIL: Status for failing flash erase or program operation
 155 */
 156enum cc1352_bootloader_status {
 157	COMMAND_RET_SUCCESS = 0x40,
 158	COMMAND_RET_UNKNOWN_CMD = 0x41,
 159	COMMAND_RET_INVALID_CMD = 0x42,
 160	COMMAND_RET_INVALID_ADR = 0x43,
 161	COMMAND_RET_FLASH_FAIL = 0x44,
 162};
 163
 164/**
 165 * struct cc1352_bootloader_packet: CC1352 Bootloader Request Packet
 166 *
 167 * @len: length of packet + optional request data
 168 * @checksum: 8-bit checksum excluding len
 169 * @cmd: bootloader command
 170 */
 171struct cc1352_bootloader_packet {
 172	u8 len;
 173	u8 checksum;
 174	u8 cmd;
 175} __packed;
 176
 177#define CC1352_BOOTLOADER_PKT_MAX_SIZE \
 178	(U8_MAX - sizeof(struct cc1352_bootloader_packet))
 179
 180/**
 181 * struct cc1352_bootloader_download_cmd_data: CC1352 Bootloader COMMAND_DOWNLOAD request data
 182 *
 183 * @addr: address to start programming data into
 184 * @size: size of data that will be sent
 185 */
 186struct cc1352_bootloader_download_cmd_data {
 187	__be32 addr;
 188	__be32 size;
 189} __packed;
 190
 191/**
 192 * struct cc1352_bootloader_crc32_cmd_data: CC1352 Bootloader COMMAND_CRC32 request data
 193 *
 194 * @addr: address where crc32 calculation starts
 195 * @size: number of bytes comprised by crc32 calculation
 196 * @read_repeat: number of read repeats for each data location
 197 */
 198struct cc1352_bootloader_crc32_cmd_data {
 199	__be32 addr;
 200	__be32 size;
 201	__be32 read_repeat;
 202} __packed;
 203
 204static void hdlc_rx_greybus_frame(struct gb_beagleplay *bg, u8 *buf, u16 len)
 205{
 206	struct hdlc_greybus_frame *gb_frame = (struct hdlc_greybus_frame *)buf;
 207	u16 cport_id = le16_to_cpu(gb_frame->cport);
 208	u16 gb_msg_len = le16_to_cpu(gb_frame->hdr.size);
 209
 210	dev_dbg(&bg->sd->dev, "Greybus Operation %u type %X cport %u status %u received",
 211		gb_frame->hdr.operation_id, gb_frame->hdr.type, cport_id, gb_frame->hdr.result);
 212
 213	greybus_data_rcvd(bg->gb_hd, cport_id, (u8 *)&gb_frame->hdr, gb_msg_len);
 214}
 215
 216static void hdlc_rx_dbg_frame(const struct gb_beagleplay *bg, const char *buf, u16 len)
 217{
 218	dev_dbg(&bg->sd->dev, "CC1352 Log: %.*s", (int)len, buf);
 219}
 220
 221/**
 222 * hdlc_write() - Consume HDLC Buffer.
 223 * @bg: beagleplay greybus driver
 224 *
 225 * Assumes that consumer lock has been acquired.
 226 */
 227static void hdlc_write(struct gb_beagleplay *bg)
 228{
 229	int written;
 230	/* Start consuming HDLC data */
 231	int head = smp_load_acquire(&bg->tx_circ_buf.head);
 232	int tail = bg->tx_circ_buf.tail;
 233	int count = CIRC_CNT_TO_END(head, tail, TX_CIRC_BUF_SIZE);
 234	const unsigned char *buf = &bg->tx_circ_buf.buf[tail];
 235
 236	if (count > 0) {
 237		written = serdev_device_write_buf(bg->sd, buf, count);
 238
 239		/* Finish consuming HDLC data */
 240		smp_store_release(&bg->tx_circ_buf.tail, (tail + written) & (TX_CIRC_BUF_SIZE - 1));
 241	}
 242}
 243
 244/**
 245 * hdlc_append() - Queue HDLC data for sending.
 246 * @bg: beagleplay greybus driver
 247 * @value: hdlc byte to transmit
 248 *
 249 * Assumes that producer lock as been acquired.
 250 */
 251static void hdlc_append(struct gb_beagleplay *bg, u8 value)
 252{
 253	int tail, head = bg->tx_circ_buf.head;
 254
 255	while (true) {
 256		tail = READ_ONCE(bg->tx_circ_buf.tail);
 257
 258		if (CIRC_SPACE(head, tail, TX_CIRC_BUF_SIZE) >= 1) {
 259			bg->tx_circ_buf.buf[head] = value;
 260
 261			/* Finish producing HDLC byte */
 262			smp_store_release(&bg->tx_circ_buf.head,
 263					  (head + 1) & (TX_CIRC_BUF_SIZE - 1));
 264			return;
 265		}
 266		dev_warn(&bg->sd->dev, "Tx circ buf full");
 267		usleep_range(3000, 5000);
 268	}
 269}
 270
 271static void hdlc_append_escaped(struct gb_beagleplay *bg, u8 value)
 272{
 273	if (value == HDLC_FRAME || value == HDLC_ESC) {
 274		hdlc_append(bg, HDLC_ESC);
 275		value ^= HDLC_XOR;
 276	}
 277	hdlc_append(bg, value);
 278}
 279
 280static void hdlc_append_tx_frame(struct gb_beagleplay *bg)
 281{
 282	bg->tx_crc = 0xFFFF;
 283	hdlc_append(bg, HDLC_FRAME);
 284}
 285
 286static void hdlc_append_tx_u8(struct gb_beagleplay *bg, u8 value)
 287{
 288	bg->tx_crc = crc_ccitt(bg->tx_crc, &value, 1);
 289	hdlc_append_escaped(bg, value);
 290}
 291
 292static void hdlc_append_tx_buf(struct gb_beagleplay *bg, const u8 *buf, u16 len)
 293{
 294	size_t i;
 295
 296	for (i = 0; i < len; i++)
 297		hdlc_append_tx_u8(bg, buf[i]);
 298}
 299
 300static void hdlc_append_tx_crc(struct gb_beagleplay *bg)
 301{
 302	bg->tx_crc ^= 0xffff;
 303	hdlc_append_escaped(bg, bg->tx_crc & 0xff);
 304	hdlc_append_escaped(bg, (bg->tx_crc >> 8) & 0xff);
 305}
 306
 307static void hdlc_transmit(struct work_struct *work)
 308{
 309	struct gb_beagleplay *bg = container_of(work, struct gb_beagleplay, tx_work);
 310
 311	spin_lock_bh(&bg->tx_consumer_lock);
 312	hdlc_write(bg);
 313	spin_unlock_bh(&bg->tx_consumer_lock);
 314}
 315
 316static void hdlc_tx_frames(struct gb_beagleplay *bg, u8 address, u8 control,
 317			   const struct hdlc_payload payloads[], size_t count)
 318{
 319	size_t i;
 320
 321	spin_lock(&bg->tx_producer_lock);
 322
 323	hdlc_append_tx_frame(bg);
 324	hdlc_append_tx_u8(bg, address);
 325	hdlc_append_tx_u8(bg, control);
 326
 327	for (i = 0; i < count; ++i)
 328		hdlc_append_tx_buf(bg, payloads[i].buf, payloads[i].len);
 329
 330	hdlc_append_tx_crc(bg);
 331	hdlc_append_tx_frame(bg);
 332
 333	spin_unlock(&bg->tx_producer_lock);
 334
 335	schedule_work(&bg->tx_work);
 336}
 337
 338static void hdlc_tx_s_frame_ack(struct gb_beagleplay *bg)
 339{
 340	hdlc_tx_frames(bg, bg->rx_buffer[0], (bg->rx_buffer[1] >> 1) & 0x7, NULL, 0);
 341}
 342
 343static void hdlc_rx_frame(struct gb_beagleplay *bg)
 344{
 345	u16 crc, len;
 346	u8 ctrl, *buf;
 347	u8 address = bg->rx_buffer[0];
 348
 349	crc = crc_ccitt(0xffff, bg->rx_buffer, bg->rx_buffer_len);
 350	if (crc != 0xf0b8) {
 351		dev_warn_ratelimited(&bg->sd->dev, "CRC failed from %02x: 0x%04x", address, crc);
 352		return;
 353	}
 354
 355	ctrl = bg->rx_buffer[1];
 356	buf = &bg->rx_buffer[2];
 357	len = bg->rx_buffer_len - 4;
 358
 359	/* I-Frame, send S-Frame ACK */
 360	if ((ctrl & 1) == 0)
 361		hdlc_tx_s_frame_ack(bg);
 362
 363	switch (address) {
 364	case ADDRESS_DBG:
 365		hdlc_rx_dbg_frame(bg, buf, len);
 366		break;
 367	case ADDRESS_GREYBUS:
 368		hdlc_rx_greybus_frame(bg, buf, len);
 369		break;
 370	default:
 371		dev_warn_ratelimited(&bg->sd->dev, "unknown frame %u", address);
 372	}
 373}
 374
 375static size_t hdlc_rx(struct gb_beagleplay *bg, const u8 *data, size_t count)
 376{
 377	size_t i;
 378	u8 c;
 379
 380	for (i = 0; i < count; ++i) {
 381		c = data[i];
 382
 383		switch (c) {
 384		case HDLC_FRAME:
 385			if (bg->rx_buffer_len)
 386				hdlc_rx_frame(bg);
 387
 388			bg->rx_buffer_len = 0;
 389			break;
 390		case HDLC_ESC:
 391			bg->rx_in_esc = true;
 392			break;
 393		default:
 394			if (bg->rx_in_esc) {
 395				c ^= 0x20;
 396				bg->rx_in_esc = false;
 397			}
 398
 399			if (bg->rx_buffer_len < MAX_RX_HDLC) {
 400				bg->rx_buffer[bg->rx_buffer_len] = c;
 401				bg->rx_buffer_len++;
 402			} else {
 403				dev_err_ratelimited(&bg->sd->dev, "RX Buffer Overflow");
 404				bg->rx_buffer_len = 0;
 405			}
 406		}
 407	}
 408
 409	return count;
 410}
 411
 412static int hdlc_init(struct gb_beagleplay *bg)
 413{
 414	INIT_WORK(&bg->tx_work, hdlc_transmit);
 415	spin_lock_init(&bg->tx_producer_lock);
 416	spin_lock_init(&bg->tx_consumer_lock);
 417	bg->tx_circ_buf.head = 0;
 418	bg->tx_circ_buf.tail = 0;
 419
 420	bg->tx_circ_buf.buf = devm_kmalloc(&bg->sd->dev, TX_CIRC_BUF_SIZE, GFP_KERNEL);
 421	if (!bg->tx_circ_buf.buf)
 422		return -ENOMEM;
 423
 424	bg->rx_buffer_len = 0;
 425	bg->rx_in_esc = false;
 426
 427	return 0;
 428}
 429
 430static void hdlc_deinit(struct gb_beagleplay *bg)
 431{
 432	flush_work(&bg->tx_work);
 433}
 434
 435/**
 436 * csum8: Calculate 8-bit checksum on data
 437 *
 438 * @data: bytes to calculate 8-bit checksum of
 439 * @size: number of bytes
 440 * @base: starting value for checksum
 441 */
 442static u8 csum8(const u8 *data, size_t size, u8 base)
 443{
 444	size_t i;
 445	u8 sum = base;
 446
 447	for (i = 0; i < size; ++i)
 448		sum += data[i];
 449
 450	return sum;
 451}
 452
 453static void cc1352_bootloader_send_ack(struct gb_beagleplay *bg)
 454{
 455	static const u8 ack[] = { 0x00, CC1352_BOOTLOADER_ACK };
 456
 457	serdev_device_write_buf(bg->sd, ack, sizeof(ack));
 458}
 459
 460static void cc1352_bootloader_send_nack(struct gb_beagleplay *bg)
 461{
 462	static const u8 nack[] = { 0x00, CC1352_BOOTLOADER_NACK };
 463
 464	serdev_device_write_buf(bg->sd, nack, sizeof(nack));
 465}
 466
 467/**
 468 * cc1352_bootloader_pkt_rx: Process a CC1352 Bootloader Packet
 469 *
 470 * @bg: beagleplay greybus driver
 471 * @data: packet buffer
 472 * @count: packet buffer size
 473 *
 474 * @return: number of bytes processed
 475 *
 476 * Here are the steps to successfully receive a packet from cc1352 bootloader
 477 * according to the docs:
 478 * 1. Wait for nonzero data to be returned from the device. This is important
 479 *    as the device may send zero bytes between a sent and a received data
 480 *    packet. The first nonzero byte received is the size of the packet that is
 481 *    being received.
 482 * 2. Read the next byte, which is the checksum for the packet.
 483 * 3. Read the data bytes from the device. During the data phase, packet size
 484 *    minus 2 bytes is sent.
 485 * 4. Calculate the checksum of the data bytes and verify it matches the
 486 *    checksum received in the packet.
 487 * 5. Send an acknowledge byte or a not-acknowledge byte to the device to
 488 *    indicate the successful or unsuccessful reception of the packet.
 489 */
 490static int cc1352_bootloader_pkt_rx(struct gb_beagleplay *bg, const u8 *data,
 491				    size_t count)
 492{
 493	bool is_valid = false;
 494
 495	switch (data[0]) {
 496	/* Skip 0x00 bytes.  */
 497	case 0x00:
 498		return 1;
 499	case CC1352_BOOTLOADER_ACK:
 500	case CC1352_BOOTLOADER_NACK:
 501		WRITE_ONCE(bg->fwl_ack, data[0]);
 502		complete(&bg->fwl_ack_com);
 503		return 1;
 504	case 3:
 505		if (count < 3)
 506			return 0;
 507		is_valid = data[1] == data[2];
 508		WRITE_ONCE(bg->fwl_cmd_response, (u32)data[2]);
 509		break;
 510	case 6:
 511		if (count < 6)
 512			return 0;
 513		is_valid = csum8(&data[2], sizeof(__be32), 0) == data[1];
 514		WRITE_ONCE(bg->fwl_cmd_response, get_unaligned_be32(&data[2]));
 515		break;
 516	default:
 517		return -EINVAL;
 518	}
 519
 520	if (is_valid) {
 521		cc1352_bootloader_send_ack(bg);
 522		complete(&bg->fwl_cmd_response_com);
 523	} else {
 524		dev_warn(&bg->sd->dev,
 525			 "Dropping bootloader packet with invalid checksum");
 526		cc1352_bootloader_send_nack(bg);
 527	}
 528
 529	return data[0];
 530}
 531
 532static size_t cc1352_bootloader_rx(struct gb_beagleplay *bg, const u8 *data,
 533				   size_t count)
 534{
 535	int ret;
 536	size_t off = 0;
 537
 538	memcpy(bg->rx_buffer + bg->rx_buffer_len, data, count);
 539	bg->rx_buffer_len += count;
 540
 541	do {
 542		ret = cc1352_bootloader_pkt_rx(bg, bg->rx_buffer + off,
 543					       bg->rx_buffer_len - off);
 544		if (ret < 0)
 545			return dev_err_probe(&bg->sd->dev, ret,
 546					     "Invalid Packet");
 547		off += ret;
 548	} while (ret > 0 && off < count);
 549
 550	bg->rx_buffer_len -= off;
 551	memmove(bg->rx_buffer, bg->rx_buffer + off, bg->rx_buffer_len);
 552
 553	return count;
 554}
 555
 556static size_t gb_tty_receive(struct serdev_device *sd, const u8 *data,
 557			     size_t count)
 558{
 559	struct gb_beagleplay *bg = serdev_device_get_drvdata(sd);
 560
 561	if (READ_ONCE(bg->flashing_mode))
 562		return cc1352_bootloader_rx(bg, data, count);
 563
 564	return hdlc_rx(bg, data, count);
 565}
 566
 567static void gb_tty_wakeup(struct serdev_device *serdev)
 568{
 569	struct gb_beagleplay *bg = serdev_device_get_drvdata(serdev);
 570
 571	if (!READ_ONCE(bg->flashing_mode))
 572		schedule_work(&bg->tx_work);
 573}
 574
 575static struct serdev_device_ops gb_beagleplay_ops = {
 576	.receive_buf = gb_tty_receive,
 577	.write_wakeup = gb_tty_wakeup,
 578};
 579
 580/**
 581 * gb_message_send() - Send greybus message using HDLC over UART
 582 *
 583 * @hd: pointer to greybus host device
 584 * @cport: AP cport where message originates
 585 * @msg: greybus message to send
 586 * @mask: gfp mask
 587 *
 588 * Greybus HDLC frame has the following payload:
 589 * 1. le16 cport
 590 * 2. gb_operation_msg_hdr msg_header
 591 * 3. u8 *msg_payload
 592 */
 593static int gb_message_send(struct gb_host_device *hd, u16 cport, struct gb_message *msg, gfp_t mask)
 594{
 595	struct gb_beagleplay *bg = dev_get_drvdata(&hd->dev);
 596	struct hdlc_payload payloads[3];
 597	__le16 cport_id = cpu_to_le16(cport);
 598
 599	dev_dbg(&hd->dev, "Sending greybus message with Operation %u, Type: %X on Cport %u",
 600		msg->header->operation_id, msg->header->type, cport);
 601
 602	if (le16_to_cpu(msg->header->size) > RX_HDLC_PAYLOAD)
 603		return dev_err_probe(&hd->dev, -E2BIG, "Greybus message too big");
 604
 605	payloads[0].buf = &cport_id;
 606	payloads[0].len = sizeof(cport_id);
 607	payloads[1].buf = msg->header;
 608	payloads[1].len = sizeof(*msg->header);
 609	payloads[2].buf = msg->payload;
 610	payloads[2].len = msg->payload_size;
 611
 612	hdlc_tx_frames(bg, ADDRESS_GREYBUS, 0x03, payloads, 3);
 613	greybus_message_sent(bg->gb_hd, msg, 0);
 614
 615	return 0;
 616}
 617
 618static void gb_message_cancel(struct gb_message *message)
 619{
 620}
 621
 622static struct gb_hd_driver gb_hdlc_driver = { .message_send = gb_message_send,
 623					      .message_cancel = gb_message_cancel };
 624
 625static void gb_beagleplay_start_svc(struct gb_beagleplay *bg)
 626{
 627	const u8 command = CONTROL_SVC_START;
 628	const struct hdlc_payload payload = { .len = 1, .buf = (void *)&command };
 629
 630	hdlc_tx_frames(bg, ADDRESS_CONTROL, 0x03, &payload, 1);
 631}
 632
 633static void gb_beagleplay_stop_svc(struct gb_beagleplay *bg)
 634{
 635	const u8 command = CONTROL_SVC_STOP;
 636	const struct hdlc_payload payload = { .len = 1, .buf = (void *)&command };
 637
 638	hdlc_tx_frames(bg, ADDRESS_CONTROL, 0x03, &payload, 1);
 639}
 640
 641static int cc1352_bootloader_wait_for_ack(struct gb_beagleplay *bg)
 642{
 643	int ret;
 644
 645	ret = wait_for_completion_timeout(
 646		&bg->fwl_ack_com, msecs_to_jiffies(CC1352_BOOTLOADER_TIMEOUT));
 647	if (!ret)
 648		return dev_err_probe(&bg->sd->dev, -ETIMEDOUT,
 649				     "Failed to acquire ack semaphore");
 650
 651	switch (READ_ONCE(bg->fwl_ack)) {
 652	case CC1352_BOOTLOADER_ACK:
 653		return 0;
 654	case CC1352_BOOTLOADER_NACK:
 655		return -EAGAIN;
 656	default:
 657		return -EINVAL;
 658	}
 659}
 660
 661static int cc1352_bootloader_sync(struct gb_beagleplay *bg)
 662{
 663	static const u8 sync_bytes[] = { 0x55, 0x55 };
 664
 665	serdev_device_write_buf(bg->sd, sync_bytes, sizeof(sync_bytes));
 666	return cc1352_bootloader_wait_for_ack(bg);
 667}
 668
 669static int cc1352_bootloader_get_status(struct gb_beagleplay *bg)
 670{
 671	int ret;
 672	static const struct cc1352_bootloader_packet pkt = {
 673		.len = sizeof(pkt),
 674		.checksum = COMMAND_GET_STATUS,
 675		.cmd = COMMAND_GET_STATUS
 676	};
 677
 678	serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
 679	ret = cc1352_bootloader_wait_for_ack(bg);
 680	if (ret < 0)
 681		return ret;
 682
 683	ret = wait_for_completion_timeout(
 684		&bg->fwl_cmd_response_com,
 685		msecs_to_jiffies(CC1352_BOOTLOADER_TIMEOUT));
 686	if (!ret)
 687		return dev_err_probe(&bg->sd->dev, -ETIMEDOUT,
 688				     "Failed to acquire last status semaphore");
 689
 690	switch (READ_ONCE(bg->fwl_cmd_response)) {
 691	case COMMAND_RET_SUCCESS:
 692		return 0;
 693	default:
 694		return -EINVAL;
 695	}
 696
 697	return 0;
 698}
 699
 700static int cc1352_bootloader_erase(struct gb_beagleplay *bg)
 701{
 702	int ret;
 703	static const struct cc1352_bootloader_packet pkt = {
 704		.len = sizeof(pkt),
 705		.checksum = COMMAND_BANK_ERASE,
 706		.cmd = COMMAND_BANK_ERASE
 707	};
 708
 709	serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
 710
 711	ret = cc1352_bootloader_wait_for_ack(bg);
 712	if (ret < 0)
 713		return ret;
 714
 715	return cc1352_bootloader_get_status(bg);
 716}
 717
 718static int cc1352_bootloader_reset(struct gb_beagleplay *bg)
 719{
 720	static const struct cc1352_bootloader_packet pkt = {
 721		.len = sizeof(pkt),
 722		.checksum = COMMAND_RESET,
 723		.cmd = COMMAND_RESET
 724	};
 725
 726	serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
 727
 728	return cc1352_bootloader_wait_for_ack(bg);
 729}
 730
 731/**
 732 * cc1352_bootloader_empty_pkt: Calculate the number of empty bytes in the current packet
 733 *
 734 * @data: packet bytes array to check
 735 * @size: number of bytes in array
 736 */
 737static size_t cc1352_bootloader_empty_pkt(const u8 *data, size_t size)
 738{
 739	size_t i;
 740
 741	for (i = 0; i < size && data[i] == 0xff; ++i)
 742		continue;
 743
 744	return i;
 745}
 746
 747static int cc1352_bootloader_crc32(struct gb_beagleplay *bg, u32 *crc32)
 748{
 749	int ret;
 750	static const struct cc1352_bootloader_crc32_cmd_data cmd_data = {
 751		.addr = 0, .size = cpu_to_be32(704 * 1024), .read_repeat = 0
 752	};
 753	const struct cc1352_bootloader_packet pkt = {
 754		.len = sizeof(pkt) + sizeof(cmd_data),
 755		.checksum = csum8((const void *)&cmd_data, sizeof(cmd_data),
 756				  COMMAND_CRC32),
 757		.cmd = COMMAND_CRC32
 758	};
 759
 760	serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
 761	serdev_device_write_buf(bg->sd, (const u8 *)&cmd_data,
 762				sizeof(cmd_data));
 763
 764	ret = cc1352_bootloader_wait_for_ack(bg);
 765	if (ret < 0)
 766		return ret;
 767
 768	ret = wait_for_completion_timeout(
 769		&bg->fwl_cmd_response_com,
 770		msecs_to_jiffies(CC1352_BOOTLOADER_TIMEOUT));
 771	if (!ret)
 772		return dev_err_probe(&bg->sd->dev, -ETIMEDOUT,
 773				     "Failed to acquire last status semaphore");
 774
 775	*crc32 = READ_ONCE(bg->fwl_cmd_response);
 776
 777	return 0;
 778}
 779
 780static int cc1352_bootloader_download(struct gb_beagleplay *bg, u32 size,
 781				      u32 addr)
 782{
 783	int ret;
 784	const struct cc1352_bootloader_download_cmd_data cmd_data = {
 785		.addr = cpu_to_be32(addr),
 786		.size = cpu_to_be32(size),
 787	};
 788	const struct cc1352_bootloader_packet pkt = {
 789		.len = sizeof(pkt) + sizeof(cmd_data),
 790		.checksum = csum8((const void *)&cmd_data, sizeof(cmd_data),
 791				  COMMAND_DOWNLOAD),
 792		.cmd = COMMAND_DOWNLOAD
 793	};
 794
 795	serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
 796	serdev_device_write_buf(bg->sd, (const u8 *)&cmd_data,
 797				sizeof(cmd_data));
 798
 799	ret = cc1352_bootloader_wait_for_ack(bg);
 800	if (ret < 0)
 801		return ret;
 802
 803	return cc1352_bootloader_get_status(bg);
 804}
 805
 806static int cc1352_bootloader_send_data(struct gb_beagleplay *bg, const u8 *data,
 807				       size_t size)
 808{
 809	int ret, rem = min(size, CC1352_BOOTLOADER_PKT_MAX_SIZE);
 810	const struct cc1352_bootloader_packet pkt = {
 811		.len = sizeof(pkt) + rem,
 812		.checksum = csum8(data, rem, COMMAND_SEND_DATA),
 813		.cmd = COMMAND_SEND_DATA
 814	};
 815
 816	serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
 817	serdev_device_write_buf(bg->sd, data, rem);
 818
 819	ret = cc1352_bootloader_wait_for_ack(bg);
 820	if (ret < 0)
 821		return ret;
 822
 823	ret = cc1352_bootloader_get_status(bg);
 824	if (ret < 0)
 825		return ret;
 826
 827	return rem;
 828}
 829
 830static void gb_greybus_deinit(struct gb_beagleplay *bg)
 831{
 832	gb_hd_del(bg->gb_hd);
 833	gb_hd_put(bg->gb_hd);
 834}
 835
 836static int gb_greybus_init(struct gb_beagleplay *bg)
 837{
 838	int ret;
 839
 840	bg->gb_hd = gb_hd_create(&gb_hdlc_driver, &bg->sd->dev, TX_CIRC_BUF_SIZE, GB_MAX_CPORTS);
 841	if (IS_ERR(bg->gb_hd)) {
 842		dev_err(&bg->sd->dev, "Failed to create greybus host device");
 843		return PTR_ERR(bg->gb_hd);
 844	}
 845
 846	ret = gb_hd_add(bg->gb_hd);
 847	if (ret) {
 848		dev_err(&bg->sd->dev, "Failed to add greybus host device");
 849		goto free_gb_hd;
 850	}
 851	dev_set_drvdata(&bg->gb_hd->dev, bg);
 852
 853	return 0;
 854
 855free_gb_hd:
 856	gb_greybus_deinit(bg);
 857	return ret;
 858}
 859
 860static enum fw_upload_err cc1352_prepare(struct fw_upload *fw_upload,
 861					 const u8 *data, u32 size)
 862{
 863	int ret;
 864	u32 curr_crc32;
 865	struct gb_beagleplay *bg = fw_upload->dd_handle;
 866
 867	dev_info(&bg->sd->dev, "CC1352 Start Flashing...");
 868
 869	if (size != CC1352_FIRMWARE_SIZE)
 870		return FW_UPLOAD_ERR_INVALID_SIZE;
 871
 872	/* Might involve network calls */
 873	gb_greybus_deinit(bg);
 874	msleep(5 * MSEC_PER_SEC);
 875
 876	gb_beagleplay_stop_svc(bg);
 877	msleep(200);
 878	flush_work(&bg->tx_work);
 879
 880	serdev_device_wait_until_sent(bg->sd, CC1352_BOOTLOADER_TIMEOUT);
 881
 882	WRITE_ONCE(bg->flashing_mode, true);
 883
 884	gpiod_direction_output(bg->bootloader_backdoor_gpio, 0);
 885	gpiod_direction_output(bg->rst_gpio, 0);
 886	msleep(200);
 887
 888	gpiod_set_value(bg->rst_gpio, 1);
 889	msleep(200);
 890
 891	gpiod_set_value(bg->bootloader_backdoor_gpio, 1);
 892	msleep(200);
 893
 894	gpiod_direction_input(bg->bootloader_backdoor_gpio);
 895	gpiod_direction_input(bg->rst_gpio);
 896
 897	ret = cc1352_bootloader_sync(bg);
 898	if (ret < 0)
 899		return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
 900				     "Failed to sync");
 901
 902	ret = cc1352_bootloader_crc32(bg, &curr_crc32);
 903	if (ret < 0)
 904		return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
 905				     "Failed to fetch crc32");
 906
 907	bg->fwl_crc32 = crc32(0xffffffff, data, size) ^ 0xffffffff;
 908
 909	/* Check if attempting to reflash same firmware */
 910	if (bg->fwl_crc32 == curr_crc32) {
 911		dev_warn(&bg->sd->dev, "Skipping reflashing same image");
 912		cc1352_bootloader_reset(bg);
 913		WRITE_ONCE(bg->flashing_mode, false);
 914		msleep(200);
 915		if (gb_greybus_init(bg) < 0)
 916			return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_RW_ERROR,
 917					     "Failed to initialize greybus");
 918		gb_beagleplay_start_svc(bg);
 919		return FW_UPLOAD_ERR_FW_INVALID;
 920	}
 921
 922	ret = cc1352_bootloader_erase(bg);
 923	if (ret < 0)
 924		return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
 925				     "Failed to erase");
 926
 927	bg->fwl_reset_addr = true;
 928
 929	return FW_UPLOAD_ERR_NONE;
 930}
 931
 932static void cc1352_cleanup(struct fw_upload *fw_upload)
 933{
 934	struct gb_beagleplay *bg = fw_upload->dd_handle;
 935
 936	WRITE_ONCE(bg->flashing_mode, false);
 937}
 938
 939static enum fw_upload_err cc1352_write(struct fw_upload *fw_upload,
 940				       const u8 *data, u32 offset, u32 size,
 941				       u32 *written)
 942{
 943	int ret;
 944	size_t empty_bytes;
 945	struct gb_beagleplay *bg = fw_upload->dd_handle;
 946
 947	/* Skip 0xff packets. Significant performance improvement */
 948	empty_bytes = cc1352_bootloader_empty_pkt(data + offset, size);
 949	if (empty_bytes >= CC1352_BOOTLOADER_PKT_MAX_SIZE) {
 950		bg->fwl_reset_addr = true;
 951		*written = empty_bytes;
 952		return FW_UPLOAD_ERR_NONE;
 953	}
 954
 955	if (bg->fwl_reset_addr) {
 956		ret = cc1352_bootloader_download(bg, size, offset);
 957		if (ret < 0)
 958			return dev_err_probe(&bg->sd->dev,
 959					     FW_UPLOAD_ERR_HW_ERROR,
 960					     "Failed to send download cmd");
 961
 962		bg->fwl_reset_addr = false;
 963	}
 964
 965	ret = cc1352_bootloader_send_data(bg, data + offset, size);
 966	if (ret < 0)
 967		return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
 968				     "Failed to flash firmware");
 969	*written = ret;
 970
 971	return FW_UPLOAD_ERR_NONE;
 972}
 973
 974static enum fw_upload_err cc1352_poll_complete(struct fw_upload *fw_upload)
 975{
 976	u32 curr_crc32;
 977	struct gb_beagleplay *bg = fw_upload->dd_handle;
 978
 979	if (cc1352_bootloader_crc32(bg, &curr_crc32) < 0)
 980		return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
 981				     "Failed to fetch crc32");
 982
 983	if (bg->fwl_crc32 != curr_crc32)
 984		return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_FW_INVALID,
 985				     "Invalid CRC32");
 986
 987	if (cc1352_bootloader_reset(bg) < 0)
 988		return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
 989				     "Failed to reset");
 990
 991	dev_info(&bg->sd->dev, "CC1352 Flashing Successful");
 992	WRITE_ONCE(bg->flashing_mode, false);
 993	msleep(200);
 994
 995	if (gb_greybus_init(bg) < 0)
 996		return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_RW_ERROR,
 997				     "Failed to initialize greybus");
 998
 999	gb_beagleplay_start_svc(bg);
1000
1001	return FW_UPLOAD_ERR_NONE;
1002}
1003
1004static void cc1352_cancel(struct fw_upload *fw_upload)
1005{
1006	struct gb_beagleplay *bg = fw_upload->dd_handle;
1007
1008	dev_info(&bg->sd->dev, "CC1352 Bootloader Cancel");
1009
1010	cc1352_bootloader_reset(bg);
1011}
1012
1013static void gb_serdev_deinit(struct gb_beagleplay *bg)
1014{
1015	serdev_device_close(bg->sd);
1016}
1017
1018static int gb_serdev_init(struct gb_beagleplay *bg)
1019{
1020	int ret;
1021
1022	serdev_device_set_drvdata(bg->sd, bg);
1023	serdev_device_set_client_ops(bg->sd, &gb_beagleplay_ops);
1024	ret = serdev_device_open(bg->sd);
1025	if (ret)
1026		return dev_err_probe(&bg->sd->dev, ret, "Unable to open serial device");
1027
1028	serdev_device_set_baudrate(bg->sd, 115200);
1029	serdev_device_set_flow_control(bg->sd, false);
1030
1031	return 0;
1032}
1033
1034static const struct fw_upload_ops cc1352_bootloader_ops = {
1035	.prepare = cc1352_prepare,
1036	.write = cc1352_write,
1037	.poll_complete = cc1352_poll_complete,
1038	.cancel = cc1352_cancel,
1039	.cleanup = cc1352_cleanup
1040};
1041
1042/*
1043 * Must only be called from probe() as the devres resources allocated here
1044 * will only be released on driver detach.
1045 */
1046static int gb_fw_init(struct gb_beagleplay *bg)
1047{
1048	struct fw_upload *fwl;
1049	struct gpio_desc *desc;
1050
1051	bg->fwl = NULL;
1052	bg->bootloader_backdoor_gpio = NULL;
1053	bg->rst_gpio = NULL;
1054	bg->flashing_mode = false;
1055	bg->fwl_cmd_response = 0;
1056	bg->fwl_ack = 0;
1057	init_completion(&bg->fwl_ack_com);
1058	init_completion(&bg->fwl_cmd_response_com);
1059
1060	desc = devm_gpiod_get(&bg->sd->dev, "bootloader-backdoor", GPIOD_IN);
1061	if (IS_ERR(desc))
1062		return PTR_ERR(desc);
1063	bg->bootloader_backdoor_gpio = desc;
1064
1065	desc = devm_gpiod_get(&bg->sd->dev, "reset", GPIOD_IN);
1066	if (IS_ERR(desc))
1067		return PTR_ERR(desc);
1068	bg->rst_gpio = desc;
1069
1070	fwl = firmware_upload_register(THIS_MODULE, &bg->sd->dev, "cc1352p7",
1071				       &cc1352_bootloader_ops, bg);
1072	if (IS_ERR(fwl))
1073		return PTR_ERR(fwl);
1074	bg->fwl = fwl;
1075
1076	return 0;
1077}
1078
1079static void gb_fw_deinit(struct gb_beagleplay *bg)
1080{
1081	firmware_upload_unregister(bg->fwl);
1082}
1083
1084static int gb_beagleplay_probe(struct serdev_device *serdev)
1085{
1086	int ret = 0;
1087	struct gb_beagleplay *bg;
1088
1089	bg = devm_kmalloc(&serdev->dev, sizeof(*bg), GFP_KERNEL);
1090	if (!bg)
1091		return -ENOMEM;
1092
1093	bg->sd = serdev;
1094	ret = gb_serdev_init(bg);
1095	if (ret)
1096		return ret;
1097
1098	ret = hdlc_init(bg);
1099	if (ret)
1100		goto free_serdev;
1101
1102	ret = gb_fw_init(bg);
1103	if (ret)
1104		goto free_hdlc;
1105
1106	ret = gb_greybus_init(bg);
1107	if (ret)
1108		goto free_fw;
1109
1110	gb_beagleplay_start_svc(bg);
1111
1112	return 0;
1113
1114free_fw:
1115	gb_fw_deinit(bg);
1116free_hdlc:
1117	hdlc_deinit(bg);
1118free_serdev:
1119	gb_serdev_deinit(bg);
1120	return ret;
1121}
1122
1123static void gb_beagleplay_remove(struct serdev_device *serdev)
1124{
1125	struct gb_beagleplay *bg = serdev_device_get_drvdata(serdev);
1126
1127	gb_fw_deinit(bg);
1128	gb_greybus_deinit(bg);
1129	gb_beagleplay_stop_svc(bg);
1130	hdlc_deinit(bg);
1131	gb_serdev_deinit(bg);
1132}
1133
1134static const struct of_device_id gb_beagleplay_of_match[] = {
1135	{
1136		.compatible = "ti,cc1352p7",
1137	},
1138	{},
1139};
1140MODULE_DEVICE_TABLE(of, gb_beagleplay_of_match);
1141
1142static struct serdev_device_driver gb_beagleplay_driver = {
1143	.probe = gb_beagleplay_probe,
1144	.remove = gb_beagleplay_remove,
1145	.driver = {
1146		.name = "gb_beagleplay",
1147		.of_match_table = gb_beagleplay_of_match,
1148	},
1149};
1150
1151module_serdev_device_driver(gb_beagleplay_driver);
1152
1153MODULE_LICENSE("GPL");
1154MODULE_AUTHOR("Ayush Singh <ayushdevel1325@gmail.com>");
1155MODULE_DESCRIPTION("A Greybus driver for BeaglePlay");