1163 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Beagleplay Linux Driver for Greybus4 *5 * Copyright (c) 2023 Ayush Singh <ayushdevel1325@gmail.com>6 * Copyright (c) 2023 BeagleBoard.org Foundation7 */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 200020#define CC1352_BOOTLOADER_ACK 0xcc21#define CC1352_BOOTLOADER_NACK 0x3322 23#define RX_HDLC_PAYLOAD 25624#define CRC_LEN 225#define MAX_RX_HDLC (1 + RX_HDLC_PAYLOAD + CRC_LEN)26#define TX_CIRC_BUF_SIZE 102427 28#define ADDRESS_GREYBUS 0x0129#define ADDRESS_DBG 0x0230#define ADDRESS_CONTROL 0x0331 32#define HDLC_FRAME 0x7E33#define HDLC_ESC 0x7D34#define HDLC_XOR 0x2035 36#define CONTROL_SVC_START 0x0137#define CONTROL_SVC_STOP 0x0238 39/* The maximum number of CPorts supported by Greybus Host Device */40#define GB_MAX_CPORTS 3241 42/**43 * struct gb_beagleplay - BeaglePlay Greybus driver44 *45 * @sd: underlying serdev device46 *47 * @gb_hd: greybus host device48 *49 * @tx_work: hdlc transmit work50 * @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 fcs54 *55 * @rx_buffer_len: length of receive buffer filled.56 * @rx_buffer: hdlc frame receive buffer57 * @rx_in_esc: hdlc rx flag to indicate ESC frame58 *59 * @fwl: underlying firmware upload device60 * @bootloader_backdoor_gpio: cc1352p7 boot gpio61 * @rst_gpio: cc1352p7 reset gpio62 * @flashing_mode: flag to indicate that flashing is currently in progress63 * @fwl_ack_com: completion to signal an Ack/Nack64 * @fwl_ack: Ack/Nack byte received65 * @fwl_cmd_response_com: completion to signal a bootloader command response66 * @fwl_cmd_response: bootloader command response data67 * @fwl_crc32: crc32 of firmware to flash68 * @fwl_reset_addr: flag to indicate if we need to send COMMAND_DOWNLOAD again69 */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 bytes101 * @buf: payload buffer102 */103struct hdlc_payload {104 u16 len;105 void *buf;106};107 108/**109 * struct hdlc_greybus_frame - Structure to represent greybus HDLC frame payload110 *111 * @cport: cport id112 * @hdr: greybus operation header113 * @payload: greybus message payload114 *115 * The HDLC payload sent over UART for greybus address has cport preappended to greybus message116 */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 Commands125 *126 * @COMMAND_DOWNLOAD: Prepares flash programming127 * @COMMAND_GET_STATUS: Returns the status of the last command that was issued128 * @COMMAND_SEND_DATA: Transfers data and programs flash129 * @COMMAND_RESET: Performs a system reset130 * @COMMAND_CRC32: Calculates CRC32 over a specified memory area131 * @COMMAND_BANK_ERASE: Performs an erase of all of the customer-accessible132 * flash sectors not protected by FCFG1 and CCFG133 * writeprotect bits.134 *135 * CC1352 Bootloader serial bus commands136 */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 response148 *149 * @COMMAND_RET_SUCCESS: Status for successful command150 * @COMMAND_RET_UNKNOWN_CMD: Status for unknown command151 * @COMMAND_RET_INVALID_CMD: Status for invalid command (in other words,152 * incorrect packet size)153 * @COMMAND_RET_INVALID_ADR: Status for invalid input address154 * @COMMAND_RET_FLASH_FAIL: Status for failing flash erase or program operation155 */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 Packet166 *167 * @len: length of packet + optional request data168 * @checksum: 8-bit checksum excluding len169 * @cmd: bootloader command170 */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 data182 *183 * @addr: address to start programming data into184 * @size: size of data that will be sent185 */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 data193 *194 * @addr: address where crc32 calculation starts195 * @size: number of bytes comprised by crc32 calculation196 * @read_repeat: number of read repeats for each data location197 */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 driver224 *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 driver247 * @value: hdlc byte to transmit248 *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 data437 *438 * @data: bytes to calculate 8-bit checksum of439 * @size: number of bytes440 * @base: starting value for checksum441 */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 Packet469 *470 * @bg: beagleplay greybus driver471 * @data: packet buffer472 * @count: packet buffer size473 *474 * @return: number of bytes processed475 *476 * Here are the steps to successfully receive a packet from cc1352 bootloader477 * according to the docs:478 * 1. Wait for nonzero data to be returned from the device. This is important479 * as the device may send zero bytes between a sent and a received data480 * packet. The first nonzero byte received is the size of the packet that is481 * 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 size484 * minus 2 bytes is sent.485 * 4. Calculate the checksum of the data bytes and verify it matches the486 * checksum received in the packet.487 * 5. Send an acknowledge byte or a not-acknowledge byte to the device to488 * 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 UART582 *583 * @hd: pointer to greybus host device584 * @cport: AP cport where message originates585 * @msg: greybus message to send586 * @mask: gfp mask587 *588 * Greybus HDLC frame has the following payload:589 * 1. le16 cport590 * 2. gb_operation_msg_hdr msg_header591 * 3. u8 *msg_payload592 */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 < 0)648 return dev_err_probe(&bg->sd->dev, ret,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_STATUS676 };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 < 0)687 return dev_err_probe(&bg->sd->dev, ret,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_ERASE707 };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_RESET724 };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 packet733 *734 * @data: packet bytes array to check735 * @size: number of bytes in array736 */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 = 0752 };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_CRC32758 };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 < 0)772 return dev_err_probe(&bg->sd->dev, ret,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_DOWNLOAD793 };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_DATA814 };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 gb_greybus_init(bg);916 gb_beagleplay_start_svc(bg);917 return FW_UPLOAD_ERR_FW_INVALID;918 }919 920 ret = cc1352_bootloader_erase(bg);921 if (ret < 0)922 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,923 "Failed to erase");924 925 bg->fwl_reset_addr = true;926 927 return FW_UPLOAD_ERR_NONE;928}929 930static void cc1352_cleanup(struct fw_upload *fw_upload)931{932 struct gb_beagleplay *bg = fw_upload->dd_handle;933 934 WRITE_ONCE(bg->flashing_mode, false);935}936 937static enum fw_upload_err cc1352_write(struct fw_upload *fw_upload,938 const u8 *data, u32 offset, u32 size,939 u32 *written)940{941 int ret;942 size_t empty_bytes;943 struct gb_beagleplay *bg = fw_upload->dd_handle;944 945 /* Skip 0xff packets. Significant performance improvement */946 empty_bytes = cc1352_bootloader_empty_pkt(data + offset, size);947 if (empty_bytes >= CC1352_BOOTLOADER_PKT_MAX_SIZE) {948 bg->fwl_reset_addr = true;949 *written = empty_bytes;950 return FW_UPLOAD_ERR_NONE;951 }952 953 if (bg->fwl_reset_addr) {954 ret = cc1352_bootloader_download(bg, size, offset);955 if (ret < 0)956 return dev_err_probe(&bg->sd->dev,957 FW_UPLOAD_ERR_HW_ERROR,958 "Failed to send download cmd");959 960 bg->fwl_reset_addr = false;961 }962 963 ret = cc1352_bootloader_send_data(bg, data + offset, size);964 if (ret < 0)965 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,966 "Failed to flash firmware");967 *written = ret;968 969 return FW_UPLOAD_ERR_NONE;970}971 972static enum fw_upload_err cc1352_poll_complete(struct fw_upload *fw_upload)973{974 u32 curr_crc32;975 struct gb_beagleplay *bg = fw_upload->dd_handle;976 977 if (cc1352_bootloader_crc32(bg, &curr_crc32) < 0)978 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,979 "Failed to fetch crc32");980 981 if (bg->fwl_crc32 != curr_crc32)982 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_FW_INVALID,983 "Invalid CRC32");984 985 if (cc1352_bootloader_reset(bg) < 0)986 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,987 "Failed to reset");988 989 dev_info(&bg->sd->dev, "CC1352 Flashing Successful");990 WRITE_ONCE(bg->flashing_mode, false);991 msleep(200);992 993 if (gb_greybus_init(bg) < 0)994 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_RW_ERROR,995 "Failed to initialize greybus");996 997 gb_beagleplay_start_svc(bg);998 999 return FW_UPLOAD_ERR_NONE;1000}1001 1002static void cc1352_cancel(struct fw_upload *fw_upload)1003{1004 struct gb_beagleplay *bg = fw_upload->dd_handle;1005 1006 dev_info(&bg->sd->dev, "CC1352 Bootloader Cancel");1007 1008 cc1352_bootloader_reset(bg);1009}1010 1011static void gb_serdev_deinit(struct gb_beagleplay *bg)1012{1013 serdev_device_close(bg->sd);1014}1015 1016static int gb_serdev_init(struct gb_beagleplay *bg)1017{1018 int ret;1019 1020 serdev_device_set_drvdata(bg->sd, bg);1021 serdev_device_set_client_ops(bg->sd, &gb_beagleplay_ops);1022 ret = serdev_device_open(bg->sd);1023 if (ret)1024 return dev_err_probe(&bg->sd->dev, ret, "Unable to open serial device");1025 1026 serdev_device_set_baudrate(bg->sd, 115200);1027 serdev_device_set_flow_control(bg->sd, false);1028 1029 return 0;1030}1031 1032static const struct fw_upload_ops cc1352_bootloader_ops = {1033 .prepare = cc1352_prepare,1034 .write = cc1352_write,1035 .poll_complete = cc1352_poll_complete,1036 .cancel = cc1352_cancel,1037 .cleanup = cc1352_cleanup1038};1039 1040static int gb_fw_init(struct gb_beagleplay *bg)1041{1042 int ret;1043 struct fw_upload *fwl;1044 struct gpio_desc *desc;1045 1046 bg->fwl = NULL;1047 bg->bootloader_backdoor_gpio = NULL;1048 bg->rst_gpio = NULL;1049 bg->flashing_mode = false;1050 bg->fwl_cmd_response = 0;1051 bg->fwl_ack = 0;1052 init_completion(&bg->fwl_ack_com);1053 init_completion(&bg->fwl_cmd_response_com);1054 1055 desc = devm_gpiod_get(&bg->sd->dev, "bootloader-backdoor", GPIOD_IN);1056 if (IS_ERR(desc))1057 return PTR_ERR(desc);1058 bg->bootloader_backdoor_gpio = desc;1059 1060 desc = devm_gpiod_get(&bg->sd->dev, "reset", GPIOD_IN);1061 if (IS_ERR(desc)) {1062 ret = PTR_ERR(desc);1063 goto free_boot;1064 }1065 bg->rst_gpio = desc;1066 1067 fwl = firmware_upload_register(THIS_MODULE, &bg->sd->dev, "cc1352p7",1068 &cc1352_bootloader_ops, bg);1069 if (IS_ERR(fwl)) {1070 ret = PTR_ERR(fwl);1071 goto free_reset;1072 }1073 bg->fwl = fwl;1074 1075 return 0;1076 1077free_reset:1078 devm_gpiod_put(&bg->sd->dev, bg->rst_gpio);1079 bg->rst_gpio = NULL;1080free_boot:1081 devm_gpiod_put(&bg->sd->dev, bg->bootloader_backdoor_gpio);1082 bg->bootloader_backdoor_gpio = NULL;1083 return ret;1084}1085 1086static void gb_fw_deinit(struct gb_beagleplay *bg)1087{1088 firmware_upload_unregister(bg->fwl);1089}1090 1091static int gb_beagleplay_probe(struct serdev_device *serdev)1092{1093 int ret = 0;1094 struct gb_beagleplay *bg;1095 1096 bg = devm_kmalloc(&serdev->dev, sizeof(*bg), GFP_KERNEL);1097 if (!bg)1098 return -ENOMEM;1099 1100 bg->sd = serdev;1101 ret = gb_serdev_init(bg);1102 if (ret)1103 return ret;1104 1105 ret = hdlc_init(bg);1106 if (ret)1107 goto free_serdev;1108 1109 ret = gb_fw_init(bg);1110 if (ret)1111 goto free_hdlc;1112 1113 ret = gb_greybus_init(bg);1114 if (ret)1115 goto free_fw;1116 1117 gb_beagleplay_start_svc(bg);1118 1119 return 0;1120 1121free_fw:1122 gb_fw_deinit(bg);1123free_hdlc:1124 hdlc_deinit(bg);1125free_serdev:1126 gb_serdev_deinit(bg);1127 return ret;1128}1129 1130static void gb_beagleplay_remove(struct serdev_device *serdev)1131{1132 struct gb_beagleplay *bg = serdev_device_get_drvdata(serdev);1133 1134 gb_fw_deinit(bg);1135 gb_greybus_deinit(bg);1136 gb_beagleplay_stop_svc(bg);1137 hdlc_deinit(bg);1138 gb_serdev_deinit(bg);1139}1140 1141static const struct of_device_id gb_beagleplay_of_match[] = {1142 {1143 .compatible = "ti,cc1352p7",1144 },1145 {},1146};1147MODULE_DEVICE_TABLE(of, gb_beagleplay_of_match);1148 1149static struct serdev_device_driver gb_beagleplay_driver = {1150 .probe = gb_beagleplay_probe,1151 .remove = gb_beagleplay_remove,1152 .driver = {1153 .name = "gb_beagleplay",1154 .of_match_table = gb_beagleplay_of_match,1155 },1156};1157 1158module_serdev_device_driver(gb_beagleplay_driver);1159 1160MODULE_LICENSE("GPL");1161MODULE_AUTHOR("Ayush Singh <ayushdevel1325@gmail.com>");1162MODULE_DESCRIPTION("A Greybus driver for BeaglePlay");1163