1 // SPDX-License-Identifier: GPL-2.0
3 * Beagleplay Linux Driver for Greybus
5 * Copyright (c) 2023 Ayush Singh <ayushdevel1325@gmail.com>
6 * Copyright (c) 2023 BeagleBoard.org Foundation
10 #include <linux/greybus.h>
11 #include <linux/module.h>
13 #include <linux/printk.h>
14 #include <linux/serdev.h>
15 #include <linux/tty.h>
16 #include <linux/tty_driver.h>
17 #include <linux/greybus/hd.h>
18 #include <linux/init.h>
19 #include <linux/device.h>
20 #include <linux/crc-ccitt.h>
21 #include <linux/circ_buf.h>
22 #include <linux/types.h>
23 #include <linux/workqueue.h>
25 #define RX_HDLC_PAYLOAD 256
27 #define MAX_RX_HDLC (1 + RX_HDLC_PAYLOAD + CRC_LEN)
28 #define TX_CIRC_BUF_SIZE 1024
30 #define ADDRESS_GREYBUS 0x01
31 #define ADDRESS_DBG 0x02
32 #define ADDRESS_CONTROL 0x03
34 #define HDLC_FRAME 0x7E
38 #define CONTROL_SVC_START 0x01
39 #define CONTROL_SVC_STOP 0x02
41 /* The maximum number of CPorts supported by Greybus Host Device */
42 #define GB_MAX_CPORTS 32
45 * struct gb_beagleplay - BeaglePlay Greybus driver
47 * @sd: underlying serdev device
49 * @gb_hd: greybus host device
51 * @tx_work: hdlc transmit work
52 * @tx_producer_lock: hdlc transmit data producer lock. acquired when appending data to buffer.
53 * @tx_consumer_lock: hdlc transmit data consumer lock. acquired when sending data over uart.
54 * @tx_circ_buf: hdlc transmit circular buffer.
55 * @tx_crc: hdlc transmit crc-ccitt fcs
57 * @rx_buffer_len: length of receive buffer filled.
58 * @rx_buffer: hdlc frame receive buffer
59 * @rx_in_esc: hdlc rx flag to indicate ESC frame
61 struct gb_beagleplay {
62 struct serdev_device *sd;
64 struct gb_host_device *gb_hd;
66 struct work_struct tx_work;
67 spinlock_t tx_producer_lock;
68 spinlock_t tx_consumer_lock;
69 struct circ_buf tx_circ_buf;
74 u8 rx_buffer[MAX_RX_HDLC];
78 * struct hdlc_payload - Structure to represent part of HDCL frame payload data.
80 * @len: buffer length in bytes
81 * @buf: payload buffer
88 static void hdlc_rx_greybus_frame(struct gb_beagleplay *bg, u8 *buf, u16 len)
91 struct gb_operation_msg_hdr *hdr = (struct gb_operation_msg_hdr *)buf;
93 memcpy(&cport_id, hdr->pad, sizeof(cport_id));
95 dev_dbg(&bg->sd->dev, "Greybus Operation %u type %X cport %u status %u received",
96 hdr->operation_id, hdr->type, cport_id, hdr->result);
98 greybus_data_rcvd(bg->gb_hd, cport_id, buf, len);
101 static void hdlc_rx_dbg_frame(const struct gb_beagleplay *bg, const char *buf, u16 len)
103 dev_dbg(&bg->sd->dev, "CC1352 Log: %.*s", (int)len, buf);
107 * hdlc_write() - Consume HDLC Buffer.
108 * @bg: beagleplay greybus driver
110 * Assumes that consumer lock has been acquired.
112 static void hdlc_write(struct gb_beagleplay *bg)
115 /* Start consuming HDLC data */
116 int head = smp_load_acquire(&bg->tx_circ_buf.head);
117 int tail = bg->tx_circ_buf.tail;
118 int count = CIRC_CNT_TO_END(head, tail, TX_CIRC_BUF_SIZE);
119 const unsigned char *buf = &bg->tx_circ_buf.buf[tail];
122 written = serdev_device_write_buf(bg->sd, buf, count);
124 /* Finish consuming HDLC data */
125 smp_store_release(&bg->tx_circ_buf.tail, (tail + written) & (TX_CIRC_BUF_SIZE - 1));
130 * hdlc_append() - Queue HDLC data for sending.
131 * @bg: beagleplay greybus driver
132 * @value: hdlc byte to transmit
134 * Assumes that producer lock as been acquired.
136 static void hdlc_append(struct gb_beagleplay *bg, u8 value)
138 int tail, head = bg->tx_circ_buf.head;
141 tail = READ_ONCE(bg->tx_circ_buf.tail);
143 if (CIRC_SPACE(head, tail, TX_CIRC_BUF_SIZE) >= 1) {
144 bg->tx_circ_buf.buf[head] = value;
146 /* Finish producing HDLC byte */
147 smp_store_release(&bg->tx_circ_buf.head,
148 (head + 1) & (TX_CIRC_BUF_SIZE - 1));
151 dev_warn(&bg->sd->dev, "Tx circ buf full");
152 usleep_range(3000, 5000);
156 static void hdlc_append_escaped(struct gb_beagleplay *bg, u8 value)
158 if (value == HDLC_FRAME || value == HDLC_ESC) {
159 hdlc_append(bg, HDLC_ESC);
162 hdlc_append(bg, value);
165 static void hdlc_append_tx_frame(struct gb_beagleplay *bg)
168 hdlc_append(bg, HDLC_FRAME);
171 static void hdlc_append_tx_u8(struct gb_beagleplay *bg, u8 value)
173 bg->tx_crc = crc_ccitt(bg->tx_crc, &value, 1);
174 hdlc_append_escaped(bg, value);
177 static void hdlc_append_tx_buf(struct gb_beagleplay *bg, const u8 *buf, u16 len)
181 for (i = 0; i < len; i++)
182 hdlc_append_tx_u8(bg, buf[i]);
185 static void hdlc_append_tx_crc(struct gb_beagleplay *bg)
187 bg->tx_crc ^= 0xffff;
188 hdlc_append_escaped(bg, bg->tx_crc & 0xff);
189 hdlc_append_escaped(bg, (bg->tx_crc >> 8) & 0xff);
192 static void hdlc_transmit(struct work_struct *work)
194 struct gb_beagleplay *bg = container_of(work, struct gb_beagleplay, tx_work);
196 spin_lock_bh(&bg->tx_consumer_lock);
198 spin_unlock_bh(&bg->tx_consumer_lock);
201 static void hdlc_tx_frames(struct gb_beagleplay *bg, u8 address, u8 control,
202 const struct hdlc_payload payloads[], size_t count)
206 spin_lock(&bg->tx_producer_lock);
208 hdlc_append_tx_frame(bg);
209 hdlc_append_tx_u8(bg, address);
210 hdlc_append_tx_u8(bg, control);
212 for (i = 0; i < count; ++i)
213 hdlc_append_tx_buf(bg, payloads[i].buf, payloads[i].len);
215 hdlc_append_tx_crc(bg);
216 hdlc_append_tx_frame(bg);
218 spin_unlock(&bg->tx_producer_lock);
220 schedule_work(&bg->tx_work);
223 static void hdlc_tx_s_frame_ack(struct gb_beagleplay *bg)
225 hdlc_tx_frames(bg, bg->rx_buffer[0], (bg->rx_buffer[1] >> 1) & 0x7, NULL, 0);
228 static void hdlc_rx_frame(struct gb_beagleplay *bg)
232 u8 address = bg->rx_buffer[0];
234 crc = crc_ccitt(0xffff, bg->rx_buffer, bg->rx_buffer_len);
236 dev_warn_ratelimited(&bg->sd->dev, "CRC failed from %02x: 0x%04x", address, crc);
240 ctrl = bg->rx_buffer[1];
241 buf = &bg->rx_buffer[2];
242 len = bg->rx_buffer_len - 4;
244 /* I-Frame, send S-Frame ACK */
246 hdlc_tx_s_frame_ack(bg);
250 hdlc_rx_dbg_frame(bg, buf, len);
252 case ADDRESS_GREYBUS:
253 hdlc_rx_greybus_frame(bg, buf, len);
256 dev_warn_ratelimited(&bg->sd->dev, "unknown frame %u", address);
260 static int hdlc_rx(struct gb_beagleplay *bg, const u8 *data, size_t count)
265 for (i = 0; i < count; ++i) {
270 if (bg->rx_buffer_len)
273 bg->rx_buffer_len = 0;
276 bg->rx_in_esc = true;
281 bg->rx_in_esc = false;
284 if (bg->rx_buffer_len < MAX_RX_HDLC) {
285 bg->rx_buffer[bg->rx_buffer_len] = c;
288 dev_err_ratelimited(&bg->sd->dev, "RX Buffer Overflow");
289 bg->rx_buffer_len = 0;
297 static int hdlc_init(struct gb_beagleplay *bg)
299 INIT_WORK(&bg->tx_work, hdlc_transmit);
300 spin_lock_init(&bg->tx_producer_lock);
301 spin_lock_init(&bg->tx_consumer_lock);
302 bg->tx_circ_buf.head = 0;
303 bg->tx_circ_buf.tail = 0;
305 bg->tx_circ_buf.buf = devm_kmalloc(&bg->sd->dev, TX_CIRC_BUF_SIZE, GFP_KERNEL);
306 if (!bg->tx_circ_buf.buf)
309 bg->rx_buffer_len = 0;
310 bg->rx_in_esc = false;
315 static void hdlc_deinit(struct gb_beagleplay *bg)
317 flush_work(&bg->tx_work);
320 static int gb_tty_receive(struct serdev_device *sd, const unsigned char *data, size_t count)
322 struct gb_beagleplay *bg = serdev_device_get_drvdata(sd);
324 return hdlc_rx(bg, data, count);
327 static void gb_tty_wakeup(struct serdev_device *serdev)
329 struct gb_beagleplay *bg = serdev_device_get_drvdata(serdev);
331 schedule_work(&bg->tx_work);
334 static struct serdev_device_ops gb_beagleplay_ops = {
335 .receive_buf = gb_tty_receive,
336 .write_wakeup = gb_tty_wakeup,
339 static int gb_message_send(struct gb_host_device *hd, u16 cport, struct gb_message *msg, gfp_t mask)
341 struct gb_beagleplay *bg = dev_get_drvdata(&hd->dev);
342 struct hdlc_payload payloads[2];
344 dev_dbg(&hd->dev, "Sending greybus message with Operation %u, Type: %X on Cport %u",
345 msg->header->operation_id, msg->header->type, cport);
347 if (msg->header->size > RX_HDLC_PAYLOAD)
348 return dev_err_probe(&hd->dev, -E2BIG, "Greybus message too big");
350 memcpy(msg->header->pad, &cport, sizeof(cport));
352 payloads[0].buf = msg->header;
353 payloads[0].len = sizeof(*msg->header);
354 payloads[1].buf = msg->payload;
355 payloads[1].len = msg->payload_size;
357 hdlc_tx_frames(bg, ADDRESS_GREYBUS, 0x03, payloads, 2);
358 greybus_message_sent(bg->gb_hd, msg, 0);
363 static void gb_message_cancel(struct gb_message *message)
367 static struct gb_hd_driver gb_hdlc_driver = { .message_send = gb_message_send,
368 .message_cancel = gb_message_cancel };
370 static void gb_beagleplay_start_svc(struct gb_beagleplay *bg)
372 const u8 command = CONTROL_SVC_START;
373 const struct hdlc_payload payload = { .len = 1, .buf = (void *)&command };
375 hdlc_tx_frames(bg, ADDRESS_CONTROL, 0x03, &payload, 1);
378 static void gb_beagleplay_stop_svc(struct gb_beagleplay *bg)
380 const u8 command = CONTROL_SVC_STOP;
381 const struct hdlc_payload payload = { .len = 1, .buf = (void *)&command };
383 hdlc_tx_frames(bg, ADDRESS_CONTROL, 0x03, &payload, 1);
386 static void gb_greybus_deinit(struct gb_beagleplay *bg)
388 gb_hd_del(bg->gb_hd);
389 gb_hd_put(bg->gb_hd);
392 static int gb_greybus_init(struct gb_beagleplay *bg)
396 bg->gb_hd = gb_hd_create(&gb_hdlc_driver, &bg->sd->dev, TX_CIRC_BUF_SIZE, GB_MAX_CPORTS);
397 if (IS_ERR(bg->gb_hd)) {
398 dev_err(&bg->sd->dev, "Failed to create greybus host device");
399 return PTR_ERR(bg->gb_hd);
402 ret = gb_hd_add(bg->gb_hd);
404 dev_err(&bg->sd->dev, "Failed to add greybus host device");
407 dev_set_drvdata(&bg->gb_hd->dev, bg);
412 gb_greybus_deinit(bg);
416 static void gb_serdev_deinit(struct gb_beagleplay *bg)
418 serdev_device_close(bg->sd);
421 static int gb_serdev_init(struct gb_beagleplay *bg)
425 serdev_device_set_drvdata(bg->sd, bg);
426 serdev_device_set_client_ops(bg->sd, &gb_beagleplay_ops);
427 ret = serdev_device_open(bg->sd);
429 return dev_err_probe(&bg->sd->dev, ret, "Unable to open serial device");
431 serdev_device_set_baudrate(bg->sd, 115200);
432 serdev_device_set_flow_control(bg->sd, false);
437 static int gb_beagleplay_probe(struct serdev_device *serdev)
440 struct gb_beagleplay *bg;
442 bg = devm_kmalloc(&serdev->dev, sizeof(*bg), GFP_KERNEL);
447 ret = gb_serdev_init(bg);
455 ret = gb_greybus_init(bg);
459 gb_beagleplay_start_svc(bg);
466 gb_serdev_deinit(bg);
470 static void gb_beagleplay_remove(struct serdev_device *serdev)
472 struct gb_beagleplay *bg = serdev_device_get_drvdata(serdev);
474 gb_greybus_deinit(bg);
475 gb_beagleplay_stop_svc(bg);
477 gb_serdev_deinit(bg);
480 static const struct of_device_id gb_beagleplay_of_match[] = {
482 .compatible = "ti,cc1352p7",
486 MODULE_DEVICE_TABLE(of, gb_beagleplay_of_match);
488 static struct serdev_device_driver gb_beagleplay_driver = {
489 .probe = gb_beagleplay_probe,
490 .remove = gb_beagleplay_remove,
492 .name = "gb_beagleplay",
493 .of_match_table = gb_beagleplay_of_match,
497 module_serdev_device_driver(gb_beagleplay_driver);
499 MODULE_LICENSE("GPL");
500 MODULE_AUTHOR("Ayush Singh <ayushdevel1325@gmail.com>");
501 MODULE_DESCRIPTION("A Greybus driver for BeaglePlay");