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 */
70 struct 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 */
103 struct 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 */
117 struct 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 */
137 enum 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 */
156 enum 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 */
171 struct 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 */
186 struct 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 */
198 struct cc1352_bootloader_crc32_cmd_data {
199 __be32 addr;
200 __be32 size;
201 __be32 read_repeat;
202 } __packed;
203
hdlc_rx_greybus_frame(struct gb_beagleplay * bg,u8 * buf,u16 len)204 static 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
hdlc_rx_dbg_frame(const struct gb_beagleplay * bg,const char * buf,u16 len)216 static 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 */
hdlc_write(struct gb_beagleplay * bg)227 static 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 */
hdlc_append(struct gb_beagleplay * bg,u8 value)251 static 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
hdlc_append_escaped(struct gb_beagleplay * bg,u8 value)271 static 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
hdlc_append_tx_frame(struct gb_beagleplay * bg)280 static void hdlc_append_tx_frame(struct gb_beagleplay *bg)
281 {
282 bg->tx_crc = 0xFFFF;
283 hdlc_append(bg, HDLC_FRAME);
284 }
285
hdlc_append_tx_u8(struct gb_beagleplay * bg,u8 value)286 static 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
hdlc_append_tx_buf(struct gb_beagleplay * bg,const u8 * buf,u16 len)292 static 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
hdlc_append_tx_crc(struct gb_beagleplay * bg)300 static 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
hdlc_transmit(struct work_struct * work)307 static 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
hdlc_tx_frames(struct gb_beagleplay * bg,u8 address,u8 control,const struct hdlc_payload payloads[],size_t count)316 static 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
hdlc_tx_s_frame_ack(struct gb_beagleplay * bg)338 static 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
hdlc_rx_frame(struct gb_beagleplay * bg)343 static 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
hdlc_rx(struct gb_beagleplay * bg,const u8 * data,size_t count)375 static 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
hdlc_init(struct gb_beagleplay * bg)412 static 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
hdlc_deinit(struct gb_beagleplay * bg)430 static 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 */
csum8(const u8 * data,size_t size,u8 base)442 static 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
cc1352_bootloader_send_ack(struct gb_beagleplay * bg)453 static 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
cc1352_bootloader_send_nack(struct gb_beagleplay * bg)460 static 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 */
cc1352_bootloader_pkt_rx(struct gb_beagleplay * bg,const u8 * data,size_t count)490 static 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
cc1352_bootloader_rx(struct gb_beagleplay * bg,const u8 * data,size_t count)532 static 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
gb_tty_receive(struct serdev_device * sd,const u8 * data,size_t count)556 static 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
gb_tty_wakeup(struct serdev_device * serdev)567 static 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
575 static 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 */
gb_message_send(struct gb_host_device * hd,u16 cport,struct gb_message * msg,gfp_t mask)593 static 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
gb_message_cancel(struct gb_message * message)618 static void gb_message_cancel(struct gb_message *message)
619 {
620 }
621
622 static struct gb_hd_driver gb_hdlc_driver = { .message_send = gb_message_send,
623 .message_cancel = gb_message_cancel };
624
gb_beagleplay_start_svc(struct gb_beagleplay * bg)625 static 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
gb_beagleplay_stop_svc(struct gb_beagleplay * bg)633 static 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
cc1352_bootloader_wait_for_ack(struct gb_beagleplay * bg)641 static 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
cc1352_bootloader_sync(struct gb_beagleplay * bg)661 static 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
cc1352_bootloader_get_status(struct gb_beagleplay * bg)669 static 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 < 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
cc1352_bootloader_erase(struct gb_beagleplay * bg)700 static 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
cc1352_bootloader_reset(struct gb_beagleplay * bg)718 static 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 */
cc1352_bootloader_empty_pkt(const u8 * data,size_t size)737 static 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
cc1352_bootloader_crc32(struct gb_beagleplay * bg,u32 * crc32)747 static 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 < 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
cc1352_bootloader_download(struct gb_beagleplay * bg,u32 size,u32 addr)780 static 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
cc1352_bootloader_send_data(struct gb_beagleplay * bg,const u8 * data,size_t size)806 static 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
gb_greybus_deinit(struct gb_beagleplay * bg)830 static 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
gb_greybus_init(struct gb_beagleplay * bg)836 static 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
855 free_gb_hd:
856 gb_greybus_deinit(bg);
857 return ret;
858 }
859
cc1352_prepare(struct fw_upload * fw_upload,const u8 * data,u32 size)860 static 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
cc1352_cleanup(struct fw_upload * fw_upload)930 static 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
cc1352_write(struct fw_upload * fw_upload,const u8 * data,u32 offset,u32 size,u32 * written)937 static 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
cc1352_poll_complete(struct fw_upload * fw_upload)972 static 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
cc1352_cancel(struct fw_upload * fw_upload)1002 static 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
gb_serdev_deinit(struct gb_beagleplay * bg)1011 static void gb_serdev_deinit(struct gb_beagleplay *bg)
1012 {
1013 serdev_device_close(bg->sd);
1014 }
1015
gb_serdev_init(struct gb_beagleplay * bg)1016 static 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
1032 static 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_cleanup
1038 };
1039
gb_fw_init(struct gb_beagleplay * bg)1040 static 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
1077 free_reset:
1078 devm_gpiod_put(&bg->sd->dev, bg->rst_gpio);
1079 bg->rst_gpio = NULL;
1080 free_boot:
1081 devm_gpiod_put(&bg->sd->dev, bg->bootloader_backdoor_gpio);
1082 bg->bootloader_backdoor_gpio = NULL;
1083 return ret;
1084 }
1085
gb_fw_deinit(struct gb_beagleplay * bg)1086 static void gb_fw_deinit(struct gb_beagleplay *bg)
1087 {
1088 firmware_upload_unregister(bg->fwl);
1089 }
1090
gb_beagleplay_probe(struct serdev_device * serdev)1091 static 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
1121 free_fw:
1122 gb_fw_deinit(bg);
1123 free_hdlc:
1124 hdlc_deinit(bg);
1125 free_serdev:
1126 gb_serdev_deinit(bg);
1127 return ret;
1128 }
1129
gb_beagleplay_remove(struct serdev_device * serdev)1130 static 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
1141 static const struct of_device_id gb_beagleplay_of_match[] = {
1142 {
1143 .compatible = "ti,cc1352p7",
1144 },
1145 {},
1146 };
1147 MODULE_DEVICE_TABLE(of, gb_beagleplay_of_match);
1148
1149 static 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
1158 module_serdev_device_driver(gb_beagleplay_driver);
1159
1160 MODULE_LICENSE("GPL");
1161 MODULE_AUTHOR("Ayush Singh <ayushdevel1325@gmail.com>");
1162 MODULE_DESCRIPTION("A Greybus driver for BeaglePlay");
1163