1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2018-2021, Intel Corporation. */
3
4 #include "ice.h"
5 #include "ice_lib.h"
6 #include <linux/tty_driver.h>
7
8 /**
9 * ice_gnss_read - Read data from internal GNSS module
10 * @work: GNSS read work structure
11 *
12 * Read the data from internal GNSS receiver, number of bytes read will be
13 * returned in *read_data parameter.
14 */
ice_gnss_read(struct kthread_work * work)15 static void ice_gnss_read(struct kthread_work *work)
16 {
17 struct gnss_serial *gnss = container_of(work, struct gnss_serial,
18 read_work.work);
19 struct ice_aqc_link_topo_addr link_topo;
20 u8 i2c_params, bytes_read;
21 struct tty_port *port;
22 struct ice_pf *pf;
23 struct ice_hw *hw;
24 __be16 data_len_b;
25 char *buf = NULL;
26 u16 i, data_len;
27 int err = 0;
28
29 pf = gnss->back;
30 if (!pf || !gnss->tty || !gnss->tty->port) {
31 err = -EFAULT;
32 goto exit;
33 }
34
35 hw = &pf->hw;
36 port = gnss->tty->port;
37
38 buf = (char *)get_zeroed_page(GFP_KERNEL);
39 if (!buf) {
40 err = -ENOMEM;
41 goto exit;
42 }
43
44 memset(&link_topo, 0, sizeof(struct ice_aqc_link_topo_addr));
45 link_topo.topo_params.index = ICE_E810T_GNSS_I2C_BUS;
46 link_topo.topo_params.node_type_ctx |=
47 FIELD_PREP(ICE_AQC_LINK_TOPO_NODE_CTX_M,
48 ICE_AQC_LINK_TOPO_NODE_CTX_OVERRIDE);
49
50 i2c_params = ICE_GNSS_UBX_DATA_LEN_WIDTH |
51 ICE_AQC_I2C_USE_REPEATED_START;
52
53 /* Read data length in a loop, when it's not 0 the data is ready */
54 for (i = 0; i < ICE_MAX_UBX_READ_TRIES; i++) {
55 err = ice_aq_read_i2c(hw, link_topo, ICE_GNSS_UBX_I2C_BUS_ADDR,
56 cpu_to_le16(ICE_GNSS_UBX_DATA_LEN_H),
57 i2c_params, (u8 *)&data_len_b, NULL);
58 if (err)
59 goto exit_buf;
60
61 data_len = be16_to_cpu(data_len_b);
62 if (data_len != 0 && data_len != U16_MAX)
63 break;
64
65 mdelay(10);
66 }
67
68 data_len = min(data_len, (u16)PAGE_SIZE);
69 data_len = tty_buffer_request_room(port, data_len);
70 if (!data_len) {
71 err = -ENOMEM;
72 goto exit_buf;
73 }
74
75 /* Read received data */
76 for (i = 0; i < data_len; i += bytes_read) {
77 u16 bytes_left = data_len - i;
78
79 bytes_read = min_t(typeof(bytes_left), bytes_left, ICE_MAX_I2C_DATA_SIZE);
80
81 err = ice_aq_read_i2c(hw, link_topo, ICE_GNSS_UBX_I2C_BUS_ADDR,
82 cpu_to_le16(ICE_GNSS_UBX_EMPTY_DATA),
83 bytes_read, &buf[i], NULL);
84 if (err)
85 goto exit_buf;
86 }
87
88 /* Send the data to the tty layer for users to read. This doesn't
89 * actually push the data through unless tty->low_latency is set.
90 */
91 tty_insert_flip_string(port, buf, i);
92 tty_flip_buffer_push(port);
93
94 exit_buf:
95 free_page((unsigned long)buf);
96 kthread_queue_delayed_work(gnss->kworker, &gnss->read_work,
97 ICE_GNSS_TIMER_DELAY_TIME);
98 exit:
99 if (err)
100 dev_dbg(ice_pf_to_dev(pf), "GNSS failed to read err=%d\n", err);
101 }
102
103 /**
104 * ice_gnss_struct_init - Initialize GNSS structure for the TTY
105 * @pf: Board private structure
106 */
ice_gnss_struct_init(struct ice_pf * pf)107 static struct gnss_serial *ice_gnss_struct_init(struct ice_pf *pf)
108 {
109 struct device *dev = ice_pf_to_dev(pf);
110 struct kthread_worker *kworker;
111 struct gnss_serial *gnss;
112
113 gnss = kzalloc(sizeof(*gnss), GFP_KERNEL);
114 if (!gnss)
115 return NULL;
116
117 mutex_init(&gnss->gnss_mutex);
118 gnss->open_count = 0;
119 gnss->back = pf;
120 pf->gnss_serial = gnss;
121
122 kthread_init_delayed_work(&gnss->read_work, ice_gnss_read);
123 /* Allocate a kworker for handling work required for the GNSS TTY
124 * writes.
125 */
126 kworker = kthread_create_worker(0, "ice-gnss-%s", dev_name(dev));
127 if (IS_ERR(kworker)) {
128 kfree(gnss);
129 return NULL;
130 }
131
132 gnss->kworker = kworker;
133
134 return gnss;
135 }
136
137 /**
138 * ice_gnss_tty_open - Initialize GNSS structures on TTY device open
139 * @tty: pointer to the tty_struct
140 * @filp: pointer to the file
141 *
142 * This routine is mandatory. If this routine is not filled in, the attempted
143 * open will fail with ENODEV.
144 */
ice_gnss_tty_open(struct tty_struct * tty,struct file * filp)145 static int ice_gnss_tty_open(struct tty_struct *tty, struct file *filp)
146 {
147 struct gnss_serial *gnss;
148 struct ice_pf *pf;
149
150 pf = (struct ice_pf *)tty->driver->driver_state;
151 if (!pf)
152 return -EFAULT;
153
154 /* Clear the pointer in case something fails */
155 tty->driver_data = NULL;
156
157 /* Get the serial object associated with this tty pointer */
158 gnss = pf->gnss_serial;
159 if (!gnss) {
160 /* Initialize GNSS struct on the first device open */
161 gnss = ice_gnss_struct_init(pf);
162 if (!gnss)
163 return -ENOMEM;
164 }
165
166 mutex_lock(&gnss->gnss_mutex);
167
168 /* Save our structure within the tty structure */
169 tty->driver_data = gnss;
170 gnss->tty = tty;
171 gnss->open_count++;
172 kthread_queue_delayed_work(gnss->kworker, &gnss->read_work, 0);
173
174 mutex_unlock(&gnss->gnss_mutex);
175
176 return 0;
177 }
178
179 /**
180 * ice_gnss_tty_close - Cleanup GNSS structures on tty device close
181 * @tty: pointer to the tty_struct
182 * @filp: pointer to the file
183 */
ice_gnss_tty_close(struct tty_struct * tty,struct file * filp)184 static void ice_gnss_tty_close(struct tty_struct *tty, struct file *filp)
185 {
186 struct gnss_serial *gnss = tty->driver_data;
187 struct ice_pf *pf;
188
189 if (!gnss)
190 return;
191
192 pf = (struct ice_pf *)tty->driver->driver_state;
193 if (!pf)
194 return;
195
196 mutex_lock(&gnss->gnss_mutex);
197
198 if (!gnss->open_count) {
199 /* Port was never opened */
200 dev_err(ice_pf_to_dev(pf), "GNSS port not opened\n");
201 goto exit;
202 }
203
204 gnss->open_count--;
205 if (gnss->open_count <= 0) {
206 /* Port is in shutdown state */
207 kthread_cancel_delayed_work_sync(&gnss->read_work);
208 }
209 exit:
210 mutex_unlock(&gnss->gnss_mutex);
211 }
212
213 /**
214 * ice_gnss_tty_write - Dummy TTY write function to avoid kernel panic
215 * @tty: pointer to the tty_struct
216 * @buf: pointer to the user data
217 * @cnt: the number of characters that was able to be sent to the hardware (or
218 * queued to be sent at a later time)
219 */
220 static int
ice_gnss_tty_write(struct tty_struct * tty,const unsigned char * buf,int cnt)221 ice_gnss_tty_write(struct tty_struct *tty, const unsigned char *buf, int cnt)
222 {
223 return 0;
224 }
225
226 /**
227 * ice_gnss_tty_write_room - Dummy TTY write_room function to avoid kernel panic
228 * @tty: pointer to the tty_struct
229 */
ice_gnss_tty_write_room(struct tty_struct * tty)230 static unsigned int ice_gnss_tty_write_room(struct tty_struct *tty)
231 {
232 return 0;
233 }
234
235 static const struct tty_operations tty_gps_ops = {
236 .open = ice_gnss_tty_open,
237 .close = ice_gnss_tty_close,
238 .write = ice_gnss_tty_write,
239 .write_room = ice_gnss_tty_write_room,
240 };
241
242 /**
243 * ice_gnss_create_tty_driver - Create a TTY driver for GNSS
244 * @pf: Board private structure
245 */
ice_gnss_create_tty_driver(struct ice_pf * pf)246 static struct tty_driver *ice_gnss_create_tty_driver(struct ice_pf *pf)
247 {
248 struct device *dev = ice_pf_to_dev(pf);
249 const int ICE_TTYDRV_NAME_MAX = 14;
250 struct tty_driver *tty_driver;
251 char *ttydrv_name;
252 int err;
253
254 tty_driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW);
255 if (IS_ERR(tty_driver)) {
256 dev_err(ice_pf_to_dev(pf), "Failed to allocate memory for GNSS TTY\n");
257 return NULL;
258 }
259
260 ttydrv_name = kzalloc(ICE_TTYDRV_NAME_MAX, GFP_KERNEL);
261 if (!ttydrv_name) {
262 tty_driver_kref_put(tty_driver);
263 return NULL;
264 }
265
266 snprintf(ttydrv_name, ICE_TTYDRV_NAME_MAX, "ttyGNSS_%02x%02x_",
267 (u8)pf->pdev->bus->number, (u8)PCI_SLOT(pf->pdev->devfn));
268
269 /* Initialize the tty driver*/
270 tty_driver->owner = THIS_MODULE;
271 tty_driver->driver_name = dev_driver_string(dev);
272 tty_driver->name = (const char *)ttydrv_name;
273 tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
274 tty_driver->subtype = SERIAL_TYPE_NORMAL;
275 tty_driver->init_termios = tty_std_termios;
276 tty_driver->init_termios.c_iflag &= ~INLCR;
277 tty_driver->init_termios.c_iflag |= IGNCR;
278 tty_driver->init_termios.c_oflag &= ~OPOST;
279 tty_driver->init_termios.c_lflag &= ~ICANON;
280 tty_driver->init_termios.c_cflag &= ~(CSIZE | CBAUD | CBAUDEX);
281 /* baud rate 9600 */
282 tty_termios_encode_baud_rate(&tty_driver->init_termios, 9600, 9600);
283 tty_driver->driver_state = pf;
284 tty_set_operations(tty_driver, &tty_gps_ops);
285
286 pf->gnss_serial = NULL;
287
288 tty_port_init(&pf->gnss_tty_port);
289 tty_port_link_device(&pf->gnss_tty_port, tty_driver, 0);
290
291 err = tty_register_driver(tty_driver);
292 if (err) {
293 dev_err(ice_pf_to_dev(pf), "Failed to register TTY driver err=%d\n",
294 err);
295
296 tty_port_destroy(&pf->gnss_tty_port);
297 kfree(ttydrv_name);
298 tty_driver_kref_put(pf->ice_gnss_tty_driver);
299
300 return NULL;
301 }
302
303 return tty_driver;
304 }
305
306 /**
307 * ice_gnss_init - Initialize GNSS TTY support
308 * @pf: Board private structure
309 */
ice_gnss_init(struct ice_pf * pf)310 void ice_gnss_init(struct ice_pf *pf)
311 {
312 struct tty_driver *tty_driver;
313
314 tty_driver = ice_gnss_create_tty_driver(pf);
315 if (!tty_driver)
316 return;
317
318 pf->ice_gnss_tty_driver = tty_driver;
319
320 set_bit(ICE_FLAG_GNSS, pf->flags);
321 dev_info(ice_pf_to_dev(pf), "GNSS TTY init successful\n");
322 }
323
324 /**
325 * ice_gnss_exit - Disable GNSS TTY support
326 * @pf: Board private structure
327 */
ice_gnss_exit(struct ice_pf * pf)328 void ice_gnss_exit(struct ice_pf *pf)
329 {
330 if (!test_bit(ICE_FLAG_GNSS, pf->flags) || !pf->ice_gnss_tty_driver)
331 return;
332
333 tty_port_destroy(&pf->gnss_tty_port);
334
335 if (pf->gnss_serial) {
336 struct gnss_serial *gnss = pf->gnss_serial;
337
338 kthread_cancel_delayed_work_sync(&gnss->read_work);
339 kfree(gnss);
340 pf->gnss_serial = NULL;
341 }
342
343 tty_unregister_driver(pf->ice_gnss_tty_driver);
344 kfree(pf->ice_gnss_tty_driver->name);
345 tty_driver_kref_put(pf->ice_gnss_tty_driver);
346 pf->ice_gnss_tty_driver = NULL;
347 }
348
349 /**
350 * ice_gnss_is_gps_present - Check if GPS HW is present
351 * @hw: pointer to HW struct
352 */
ice_gnss_is_gps_present(struct ice_hw * hw)353 bool ice_gnss_is_gps_present(struct ice_hw *hw)
354 {
355 if (!hw->func_caps.ts_func_info.src_tmr_owned)
356 return false;
357
358 #if IS_ENABLED(CONFIG_PTP_1588_CLOCK)
359 if (ice_is_e810t(hw)) {
360 int err;
361 u8 data;
362
363 err = ice_read_pca9575_reg_e810t(hw, ICE_PCA9575_P0_IN, &data);
364 if (err || !!(data & ICE_E810T_P0_GNSS_PRSNT_N))
365 return false;
366 } else {
367 return false;
368 }
369 #else
370 if (!ice_is_e810t(hw))
371 return false;
372 #endif /* IS_ENABLED(CONFIG_PTP_1588_CLOCK) */
373
374 return true;
375 }
376