Lines Matching refs:bg
204 static void hdlc_rx_greybus_frame(struct gb_beagleplay *bg, u8 *buf, u16 len)
210 dev_dbg(&bg->sd->dev, "Greybus Operation %u type %X cport %u status %u received",
213 greybus_data_rcvd(bg->gb_hd, cport_id, (u8 *)&gb_frame->hdr, gb_msg_len);
216 static void hdlc_rx_dbg_frame(const struct gb_beagleplay *bg, const char *buf, u16 len)
218 dev_dbg(&bg->sd->dev, "CC1352 Log: %.*s", (int)len, buf);
223 * @bg: beagleplay greybus driver
227 static void hdlc_write(struct gb_beagleplay *bg)
231 int head = smp_load_acquire(&bg->tx_circ_buf.head);
232 int tail = bg->tx_circ_buf.tail;
234 const unsigned char *buf = &bg->tx_circ_buf.buf[tail];
237 written = serdev_device_write_buf(bg->sd, buf, count);
240 smp_store_release(&bg->tx_circ_buf.tail, (tail + written) & (TX_CIRC_BUF_SIZE - 1));
246 * @bg: beagleplay greybus driver
251 static void hdlc_append(struct gb_beagleplay *bg, u8 value)
253 int tail, head = bg->tx_circ_buf.head;
256 tail = READ_ONCE(bg->tx_circ_buf.tail);
259 bg->tx_circ_buf.buf[head] = value;
262 smp_store_release(&bg->tx_circ_buf.head,
266 dev_warn(&bg->sd->dev, "Tx circ buf full");
271 static void hdlc_append_escaped(struct gb_beagleplay *bg, u8 value)
274 hdlc_append(bg, HDLC_ESC);
277 hdlc_append(bg, value);
280 static void hdlc_append_tx_frame(struct gb_beagleplay *bg)
282 bg->tx_crc = 0xFFFF;
283 hdlc_append(bg, HDLC_FRAME);
286 static void hdlc_append_tx_u8(struct gb_beagleplay *bg, u8 value)
288 bg->tx_crc = crc_ccitt(bg->tx_crc, &value, 1);
289 hdlc_append_escaped(bg, value);
292 static void hdlc_append_tx_buf(struct gb_beagleplay *bg, const u8 *buf, u16 len)
297 hdlc_append_tx_u8(bg, buf[i]);
300 static void hdlc_append_tx_crc(struct gb_beagleplay *bg)
302 bg->tx_crc ^= 0xffff;
303 hdlc_append_escaped(bg, bg->tx_crc & 0xff);
304 hdlc_append_escaped(bg, (bg->tx_crc >> 8) & 0xff);
309 struct gb_beagleplay *bg = container_of(work, struct gb_beagleplay, tx_work);
311 spin_lock_bh(&bg->tx_consumer_lock);
312 hdlc_write(bg);
313 spin_unlock_bh(&bg->tx_consumer_lock);
316 static void hdlc_tx_frames(struct gb_beagleplay *bg, u8 address, u8 control,
321 spin_lock(&bg->tx_producer_lock);
323 hdlc_append_tx_frame(bg);
324 hdlc_append_tx_u8(bg, address);
325 hdlc_append_tx_u8(bg, control);
328 hdlc_append_tx_buf(bg, payloads[i].buf, payloads[i].len);
330 hdlc_append_tx_crc(bg);
331 hdlc_append_tx_frame(bg);
333 spin_unlock(&bg->tx_producer_lock);
335 schedule_work(&bg->tx_work);
338 static void hdlc_tx_s_frame_ack(struct gb_beagleplay *bg)
340 hdlc_tx_frames(bg, bg->rx_buffer[0], (bg->rx_buffer[1] >> 1) & 0x7, NULL, 0);
343 static void hdlc_rx_frame(struct gb_beagleplay *bg)
347 u8 address = bg->rx_buffer[0];
349 crc = crc_ccitt(0xffff, bg->rx_buffer, bg->rx_buffer_len);
351 dev_warn_ratelimited(&bg->sd->dev, "CRC failed from %02x: 0x%04x", address, crc);
355 ctrl = bg->rx_buffer[1];
356 buf = &bg->rx_buffer[2];
357 len = bg->rx_buffer_len - 4;
361 hdlc_tx_s_frame_ack(bg);
365 hdlc_rx_dbg_frame(bg, buf, len);
368 hdlc_rx_greybus_frame(bg, buf, len);
371 dev_warn_ratelimited(&bg->sd->dev, "unknown frame %u", address);
375 static size_t hdlc_rx(struct gb_beagleplay *bg, const u8 *data, size_t count)
385 if (bg->rx_buffer_len)
386 hdlc_rx_frame(bg);
388 bg->rx_buffer_len = 0;
391 bg->rx_in_esc = true;
394 if (bg->rx_in_esc) {
396 bg->rx_in_esc = false;
399 if (bg->rx_buffer_len < MAX_RX_HDLC) {
400 bg->rx_buffer[bg->rx_buffer_len] = c;
401 bg->rx_buffer_len++;
403 dev_err_ratelimited(&bg->sd->dev, "RX Buffer Overflow");
404 bg->rx_buffer_len = 0;
412 static int hdlc_init(struct gb_beagleplay *bg)
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;
420 bg->tx_circ_buf.buf = devm_kmalloc(&bg->sd->dev, TX_CIRC_BUF_SIZE, GFP_KERNEL);
421 if (!bg->tx_circ_buf.buf)
424 bg->rx_buffer_len = 0;
425 bg->rx_in_esc = false;
430 static void hdlc_deinit(struct gb_beagleplay *bg)
432 flush_work(&bg->tx_work);
453 static void cc1352_bootloader_send_ack(struct gb_beagleplay *bg)
457 serdev_device_write_buf(bg->sd, ack, sizeof(ack));
460 static void cc1352_bootloader_send_nack(struct gb_beagleplay *bg)
464 serdev_device_write_buf(bg->sd, nack, sizeof(nack));
470 * @bg: beagleplay greybus driver
490 static int cc1352_bootloader_pkt_rx(struct gb_beagleplay *bg, const u8 *data,
501 WRITE_ONCE(bg->fwl_ack, data[0]);
502 complete(&bg->fwl_ack_com);
508 WRITE_ONCE(bg->fwl_cmd_response, (u32)data[2]);
514 WRITE_ONCE(bg->fwl_cmd_response, get_unaligned_be32(&data[2]));
521 cc1352_bootloader_send_ack(bg);
522 complete(&bg->fwl_cmd_response_com);
524 dev_warn(&bg->sd->dev,
526 cc1352_bootloader_send_nack(bg);
532 static size_t cc1352_bootloader_rx(struct gb_beagleplay *bg, const u8 *data,
538 memcpy(bg->rx_buffer + bg->rx_buffer_len, data, count);
539 bg->rx_buffer_len += count;
542 ret = cc1352_bootloader_pkt_rx(bg, bg->rx_buffer + off,
543 bg->rx_buffer_len - off);
545 return dev_err_probe(&bg->sd->dev, ret,
550 bg->rx_buffer_len -= off;
551 memmove(bg->rx_buffer, bg->rx_buffer + off, bg->rx_buffer_len);
559 struct gb_beagleplay *bg = serdev_device_get_drvdata(sd);
561 if (READ_ONCE(bg->flashing_mode))
562 return cc1352_bootloader_rx(bg, data, count);
564 return hdlc_rx(bg, data, count);
569 struct gb_beagleplay *bg = serdev_device_get_drvdata(serdev);
571 if (!READ_ONCE(bg->flashing_mode))
572 schedule_work(&bg->tx_work);
595 struct gb_beagleplay *bg = dev_get_drvdata(&hd->dev);
612 hdlc_tx_frames(bg, ADDRESS_GREYBUS, 0x03, payloads, 3);
613 greybus_message_sent(bg->gb_hd, msg, 0);
625 static void gb_beagleplay_start_svc(struct gb_beagleplay *bg)
630 hdlc_tx_frames(bg, ADDRESS_CONTROL, 0x03, &payload, 1);
633 static void gb_beagleplay_stop_svc(struct gb_beagleplay *bg)
638 hdlc_tx_frames(bg, ADDRESS_CONTROL, 0x03, &payload, 1);
641 static int cc1352_bootloader_wait_for_ack(struct gb_beagleplay *bg)
646 &bg->fwl_ack_com, msecs_to_jiffies(CC1352_BOOTLOADER_TIMEOUT));
648 return dev_err_probe(&bg->sd->dev, ret,
651 switch (READ_ONCE(bg->fwl_ack)) {
661 static int cc1352_bootloader_sync(struct gb_beagleplay *bg)
665 serdev_device_write_buf(bg->sd, sync_bytes, sizeof(sync_bytes));
666 return cc1352_bootloader_wait_for_ack(bg);
669 static int cc1352_bootloader_get_status(struct gb_beagleplay *bg)
678 serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
679 ret = cc1352_bootloader_wait_for_ack(bg);
684 &bg->fwl_cmd_response_com,
687 return dev_err_probe(&bg->sd->dev, ret,
690 switch (READ_ONCE(bg->fwl_cmd_response)) {
700 static int cc1352_bootloader_erase(struct gb_beagleplay *bg)
709 serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
711 ret = cc1352_bootloader_wait_for_ack(bg);
715 return cc1352_bootloader_get_status(bg);
718 static int cc1352_bootloader_reset(struct gb_beagleplay *bg)
726 serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
728 return cc1352_bootloader_wait_for_ack(bg);
747 static int cc1352_bootloader_crc32(struct gb_beagleplay *bg, u32 *crc32)
760 serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
761 serdev_device_write_buf(bg->sd, (const u8 *)&cmd_data,
764 ret = cc1352_bootloader_wait_for_ack(bg);
769 &bg->fwl_cmd_response_com,
772 return dev_err_probe(&bg->sd->dev, ret,
775 *crc32 = READ_ONCE(bg->fwl_cmd_response);
780 static int cc1352_bootloader_download(struct gb_beagleplay *bg, u32 size,
795 serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
796 serdev_device_write_buf(bg->sd, (const u8 *)&cmd_data,
799 ret = cc1352_bootloader_wait_for_ack(bg);
803 return cc1352_bootloader_get_status(bg);
806 static int cc1352_bootloader_send_data(struct gb_beagleplay *bg, const u8 *data,
816 serdev_device_write_buf(bg->sd, (const u8 *)&pkt, sizeof(pkt));
817 serdev_device_write_buf(bg->sd, data, rem);
819 ret = cc1352_bootloader_wait_for_ack(bg);
823 ret = cc1352_bootloader_get_status(bg);
830 static void gb_greybus_deinit(struct gb_beagleplay *bg)
832 gb_hd_del(bg->gb_hd);
833 gb_hd_put(bg->gb_hd);
836 static int gb_greybus_init(struct gb_beagleplay *bg)
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);
846 ret = gb_hd_add(bg->gb_hd);
848 dev_err(&bg->sd->dev, "Failed to add greybus host device");
851 dev_set_drvdata(&bg->gb_hd->dev, bg);
856 gb_greybus_deinit(bg);
865 struct gb_beagleplay *bg = fw_upload->dd_handle;
867 dev_info(&bg->sd->dev, "CC1352 Start Flashing...");
873 gb_greybus_deinit(bg);
876 gb_beagleplay_stop_svc(bg);
878 flush_work(&bg->tx_work);
880 serdev_device_wait_until_sent(bg->sd, CC1352_BOOTLOADER_TIMEOUT);
882 WRITE_ONCE(bg->flashing_mode, true);
884 gpiod_direction_output(bg->bootloader_backdoor_gpio, 0);
885 gpiod_direction_output(bg->rst_gpio, 0);
888 gpiod_set_value(bg->rst_gpio, 1);
891 gpiod_set_value(bg->bootloader_backdoor_gpio, 1);
894 gpiod_direction_input(bg->bootloader_backdoor_gpio);
895 gpiod_direction_input(bg->rst_gpio);
897 ret = cc1352_bootloader_sync(bg);
899 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
902 ret = cc1352_bootloader_crc32(bg, &curr_crc32);
904 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
907 bg->fwl_crc32 = crc32(0xffffffff, data, size) ^ 0xffffffff;
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);
915 if (gb_greybus_init(bg) < 0)
916 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_RW_ERROR,
918 gb_beagleplay_start_svc(bg);
922 ret = cc1352_bootloader_erase(bg);
924 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
927 bg->fwl_reset_addr = true;
934 struct gb_beagleplay *bg = fw_upload->dd_handle;
936 WRITE_ONCE(bg->flashing_mode, false);
945 struct gb_beagleplay *bg = fw_upload->dd_handle;
950 bg->fwl_reset_addr = true;
955 if (bg->fwl_reset_addr) {
956 ret = cc1352_bootloader_download(bg, size, offset);
958 return dev_err_probe(&bg->sd->dev,
962 bg->fwl_reset_addr = false;
965 ret = cc1352_bootloader_send_data(bg, data + offset, size);
967 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
977 struct gb_beagleplay *bg = fw_upload->dd_handle;
979 if (cc1352_bootloader_crc32(bg, &curr_crc32) < 0)
980 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
983 if (bg->fwl_crc32 != curr_crc32)
984 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_FW_INVALID,
987 if (cc1352_bootloader_reset(bg) < 0)
988 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_HW_ERROR,
991 dev_info(&bg->sd->dev, "CC1352 Flashing Successful");
992 WRITE_ONCE(bg->flashing_mode, false);
995 if (gb_greybus_init(bg) < 0)
996 return dev_err_probe(&bg->sd->dev, FW_UPLOAD_ERR_RW_ERROR,
999 gb_beagleplay_start_svc(bg);
1006 struct gb_beagleplay *bg = fw_upload->dd_handle;
1008 dev_info(&bg->sd->dev, "CC1352 Bootloader Cancel");
1010 cc1352_bootloader_reset(bg);
1013 static void gb_serdev_deinit(struct gb_beagleplay *bg)
1015 serdev_device_close(bg->sd);
1018 static int gb_serdev_init(struct gb_beagleplay *bg)
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);
1026 return dev_err_probe(&bg->sd->dev, ret, "Unable to open serial device");
1028 serdev_device_set_baudrate(bg->sd, 115200);
1029 serdev_device_set_flow_control(bg->sd, false);
1046 static int gb_fw_init(struct gb_beagleplay *bg)
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);
1060 desc = devm_gpiod_get(&bg->sd->dev, "bootloader-backdoor", GPIOD_IN);
1063 bg->bootloader_backdoor_gpio = desc;
1065 desc = devm_gpiod_get(&bg->sd->dev, "reset", GPIOD_IN);
1068 bg->rst_gpio = desc;
1070 fwl = firmware_upload_register(THIS_MODULE, &bg->sd->dev, "cc1352p7",
1071 &cc1352_bootloader_ops, bg);
1074 bg->fwl = fwl;
1079 static void gb_fw_deinit(struct gb_beagleplay *bg)
1081 firmware_upload_unregister(bg->fwl);
1087 struct gb_beagleplay *bg;
1089 bg = devm_kmalloc(&serdev->dev, sizeof(*bg), GFP_KERNEL);
1090 if (!bg)
1093 bg->sd = serdev;
1094 ret = gb_serdev_init(bg);
1098 ret = hdlc_init(bg);
1102 ret = gb_fw_init(bg);
1106 ret = gb_greybus_init(bg);
1110 gb_beagleplay_start_svc(bg);
1115 gb_fw_deinit(bg);
1117 hdlc_deinit(bg);
1119 gb_serdev_deinit(bg);
1125 struct gb_beagleplay *bg = serdev_device_get_drvdata(serdev);
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);