1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2021-2022, Intel Corporation. */ 3 4 #include "ice.h" 5 #include "ice_lib.h" 6 #include <linux/tty_driver.h> 7 8 /** 9 * ice_gnss_do_write - Write data to internal GNSS 10 * @pf: board private structure 11 * @buf: command buffer 12 * @size: command buffer size 13 * 14 * Write UBX command data to the GNSS receiver 15 */ 16 static unsigned int 17 ice_gnss_do_write(struct ice_pf *pf, unsigned char *buf, unsigned int size) 18 { 19 struct ice_aqc_link_topo_addr link_topo; 20 struct ice_hw *hw = &pf->hw; 21 unsigned int offset = 0; 22 int err = 0; 23 24 memset(&link_topo, 0, sizeof(struct ice_aqc_link_topo_addr)); 25 link_topo.topo_params.index = ICE_E810T_GNSS_I2C_BUS; 26 link_topo.topo_params.node_type_ctx |= 27 FIELD_PREP(ICE_AQC_LINK_TOPO_NODE_CTX_M, 28 ICE_AQC_LINK_TOPO_NODE_CTX_OVERRIDE); 29 30 /* It's not possible to write a single byte to u-blox. 31 * Write all bytes in a loop until there are 6 or less bytes left. If 32 * there are exactly 6 bytes left, the last write would be only a byte. 33 * In this case, do 4+2 bytes writes instead of 5+1. Otherwise, do the 34 * last 2 to 5 bytes write. 35 */ 36 while (size - offset > ICE_GNSS_UBX_WRITE_BYTES + 1) { 37 err = ice_aq_write_i2c(hw, link_topo, ICE_GNSS_UBX_I2C_BUS_ADDR, 38 cpu_to_le16(buf[offset]), 39 ICE_MAX_I2C_WRITE_BYTES, 40 &buf[offset + 1], NULL); 41 if (err) 42 goto err_out; 43 44 offset += ICE_GNSS_UBX_WRITE_BYTES; 45 } 46 47 /* Single byte would be written. Write 4 bytes instead of 5. */ 48 if (size - offset == ICE_GNSS_UBX_WRITE_BYTES + 1) { 49 err = ice_aq_write_i2c(hw, link_topo, ICE_GNSS_UBX_I2C_BUS_ADDR, 50 cpu_to_le16(buf[offset]), 51 ICE_MAX_I2C_WRITE_BYTES - 1, 52 &buf[offset + 1], NULL); 53 if (err) 54 goto err_out; 55 56 offset += ICE_GNSS_UBX_WRITE_BYTES - 1; 57 } 58 59 /* Do the last write, 2 to 5 bytes. */ 60 err = ice_aq_write_i2c(hw, link_topo, ICE_GNSS_UBX_I2C_BUS_ADDR, 61 cpu_to_le16(buf[offset]), size - offset - 1, 62 &buf[offset + 1], NULL); 63 if (err) 64 goto err_out; 65 66 return size; 67 68 err_out: 69 dev_err(ice_pf_to_dev(pf), "GNSS failed to write, offset=%u, size=%u, err=%d\n", 70 offset, size, err); 71 72 return offset; 73 } 74 75 /** 76 * ice_gnss_write_pending - Write all pending data to internal GNSS 77 * @work: GNSS write work structure 78 */ 79 static void ice_gnss_write_pending(struct kthread_work *work) 80 { 81 struct gnss_serial *gnss = container_of(work, struct gnss_serial, 82 write_work); 83 struct ice_pf *pf = gnss->back; 84 85 if (!list_empty(&gnss->queue)) { 86 struct gnss_write_buf *write_buf = NULL; 87 unsigned int bytes; 88 89 write_buf = list_first_entry(&gnss->queue, 90 struct gnss_write_buf, queue); 91 92 bytes = ice_gnss_do_write(pf, write_buf->buf, write_buf->size); 93 dev_dbg(ice_pf_to_dev(pf), "%u bytes written to GNSS\n", bytes); 94 95 list_del(&write_buf->queue); 96 kfree(write_buf->buf); 97 kfree(write_buf); 98 } 99 } 100 101 /** 102 * ice_gnss_read - Read data from internal GNSS module 103 * @work: GNSS read work structure 104 * 105 * Read the data from internal GNSS receiver, number of bytes read will be 106 * returned in *read_data parameter. 107 */ 108 static void ice_gnss_read(struct kthread_work *work) 109 { 110 struct gnss_serial *gnss = container_of(work, struct gnss_serial, 111 read_work.work); 112 struct ice_aqc_link_topo_addr link_topo; 113 unsigned int i, bytes_read, data_len; 114 struct tty_port *port; 115 struct ice_pf *pf; 116 struct ice_hw *hw; 117 __be16 data_len_b; 118 char *buf = NULL; 119 u8 i2c_params; 120 int err = 0; 121 122 pf = gnss->back; 123 if (!pf || !gnss->tty || !gnss->tty->port) { 124 err = -EFAULT; 125 goto exit; 126 } 127 128 hw = &pf->hw; 129 port = gnss->tty->port; 130 131 buf = (char *)get_zeroed_page(GFP_KERNEL); 132 if (!buf) { 133 err = -ENOMEM; 134 goto exit; 135 } 136 137 memset(&link_topo, 0, sizeof(struct ice_aqc_link_topo_addr)); 138 link_topo.topo_params.index = ICE_E810T_GNSS_I2C_BUS; 139 link_topo.topo_params.node_type_ctx |= 140 FIELD_PREP(ICE_AQC_LINK_TOPO_NODE_CTX_M, 141 ICE_AQC_LINK_TOPO_NODE_CTX_OVERRIDE); 142 143 i2c_params = ICE_GNSS_UBX_DATA_LEN_WIDTH | 144 ICE_AQC_I2C_USE_REPEATED_START; 145 146 /* Read data length in a loop, when it's not 0 the data is ready */ 147 for (i = 0; i < ICE_MAX_UBX_READ_TRIES; i++) { 148 err = ice_aq_read_i2c(hw, link_topo, ICE_GNSS_UBX_I2C_BUS_ADDR, 149 cpu_to_le16(ICE_GNSS_UBX_DATA_LEN_H), 150 i2c_params, (u8 *)&data_len_b, NULL); 151 if (err) 152 goto exit_buf; 153 154 data_len = be16_to_cpu(data_len_b); 155 if (data_len != 0 && data_len != U16_MAX) 156 break; 157 158 mdelay(10); 159 } 160 161 data_len = min_t(typeof(data_len), data_len, PAGE_SIZE); 162 data_len = tty_buffer_request_room(port, data_len); 163 if (!data_len) { 164 err = -ENOMEM; 165 goto exit_buf; 166 } 167 168 /* Read received data */ 169 for (i = 0; i < data_len; i += bytes_read) { 170 unsigned int bytes_left = data_len - i; 171 172 bytes_read = min_t(typeof(bytes_left), bytes_left, 173 ICE_MAX_I2C_DATA_SIZE); 174 175 err = ice_aq_read_i2c(hw, link_topo, ICE_GNSS_UBX_I2C_BUS_ADDR, 176 cpu_to_le16(ICE_GNSS_UBX_EMPTY_DATA), 177 bytes_read, &buf[i], NULL); 178 if (err) 179 goto exit_buf; 180 } 181 182 /* Send the data to the tty layer for users to read. This doesn't 183 * actually push the data through unless tty->low_latency is set. 184 */ 185 tty_insert_flip_string(port, buf, i); 186 tty_flip_buffer_push(port); 187 188 exit_buf: 189 free_page((unsigned long)buf); 190 kthread_queue_delayed_work(gnss->kworker, &gnss->read_work, 191 ICE_GNSS_TIMER_DELAY_TIME); 192 exit: 193 if (err) 194 dev_dbg(ice_pf_to_dev(pf), "GNSS failed to read err=%d\n", err); 195 } 196 197 /** 198 * ice_gnss_struct_init - Initialize GNSS structure for the TTY 199 * @pf: Board private structure 200 * @index: TTY device index 201 */ 202 static struct gnss_serial *ice_gnss_struct_init(struct ice_pf *pf, int index) 203 { 204 struct device *dev = ice_pf_to_dev(pf); 205 struct kthread_worker *kworker; 206 struct gnss_serial *gnss; 207 208 gnss = kzalloc(sizeof(*gnss), GFP_KERNEL); 209 if (!gnss) 210 return NULL; 211 212 mutex_init(&gnss->gnss_mutex); 213 gnss->open_count = 0; 214 gnss->back = pf; 215 pf->gnss_serial[index] = gnss; 216 217 kthread_init_delayed_work(&gnss->read_work, ice_gnss_read); 218 INIT_LIST_HEAD(&gnss->queue); 219 kthread_init_work(&gnss->write_work, ice_gnss_write_pending); 220 /* Allocate a kworker for handling work required for the GNSS TTY 221 * writes. 222 */ 223 kworker = kthread_create_worker(0, "ice-gnss-%s", dev_name(dev)); 224 if (IS_ERR(kworker)) { 225 kfree(gnss); 226 return NULL; 227 } 228 229 gnss->kworker = kworker; 230 231 return gnss; 232 } 233 234 /** 235 * ice_gnss_tty_open - Initialize GNSS structures on TTY device open 236 * @tty: pointer to the tty_struct 237 * @filp: pointer to the file 238 * 239 * This routine is mandatory. If this routine is not filled in, the attempted 240 * open will fail with ENODEV. 241 */ 242 static int ice_gnss_tty_open(struct tty_struct *tty, struct file *filp) 243 { 244 struct gnss_serial *gnss; 245 struct ice_pf *pf; 246 247 pf = (struct ice_pf *)tty->driver->driver_state; 248 if (!pf) 249 return -EFAULT; 250 251 /* Clear the pointer in case something fails */ 252 tty->driver_data = NULL; 253 254 /* Get the serial object associated with this tty pointer */ 255 gnss = pf->gnss_serial[tty->index]; 256 if (!gnss) { 257 /* Initialize GNSS struct on the first device open */ 258 gnss = ice_gnss_struct_init(pf, tty->index); 259 if (!gnss) 260 return -ENOMEM; 261 } 262 263 mutex_lock(&gnss->gnss_mutex); 264 265 /* Save our structure within the tty structure */ 266 tty->driver_data = gnss; 267 gnss->tty = tty; 268 gnss->open_count++; 269 kthread_queue_delayed_work(gnss->kworker, &gnss->read_work, 0); 270 271 mutex_unlock(&gnss->gnss_mutex); 272 273 return 0; 274 } 275 276 /** 277 * ice_gnss_tty_close - Cleanup GNSS structures on tty device close 278 * @tty: pointer to the tty_struct 279 * @filp: pointer to the file 280 */ 281 static void ice_gnss_tty_close(struct tty_struct *tty, struct file *filp) 282 { 283 struct gnss_serial *gnss = tty->driver_data; 284 struct ice_pf *pf; 285 286 if (!gnss) 287 return; 288 289 pf = (struct ice_pf *)tty->driver->driver_state; 290 if (!pf) 291 return; 292 293 mutex_lock(&gnss->gnss_mutex); 294 295 if (!gnss->open_count) { 296 /* Port was never opened */ 297 dev_err(ice_pf_to_dev(pf), "GNSS port not opened\n"); 298 goto exit; 299 } 300 301 gnss->open_count--; 302 if (gnss->open_count <= 0) { 303 /* Port is in shutdown state */ 304 kthread_cancel_delayed_work_sync(&gnss->read_work); 305 } 306 exit: 307 mutex_unlock(&gnss->gnss_mutex); 308 } 309 310 /** 311 * ice_gnss_tty_write - Write GNSS data 312 * @tty: pointer to the tty_struct 313 * @buf: pointer to the user data 314 * @count: the number of characters queued to be sent to the HW 315 * 316 * The write function call is called by the user when there is data to be sent 317 * to the hardware. First the tty core receives the call, and then it passes the 318 * data on to the tty driver's write function. The tty core also tells the tty 319 * driver the size of the data being sent. 320 * If any errors happen during the write call, a negative error value should be 321 * returned instead of the number of characters queued to be written. 322 */ 323 static int 324 ice_gnss_tty_write(struct tty_struct *tty, const unsigned char *buf, int count) 325 { 326 struct gnss_write_buf *write_buf; 327 struct gnss_serial *gnss; 328 unsigned char *cmd_buf; 329 struct ice_pf *pf; 330 int err = count; 331 332 /* We cannot write a single byte using our I2C implementation. */ 333 if (count <= 1 || count > ICE_GNSS_TTY_WRITE_BUF) 334 return -EINVAL; 335 336 gnss = tty->driver_data; 337 if (!gnss) 338 return -EFAULT; 339 340 pf = (struct ice_pf *)tty->driver->driver_state; 341 if (!pf) 342 return -EFAULT; 343 344 /* Only allow to write on TTY 0 */ 345 if (gnss != pf->gnss_serial[0]) 346 return -EIO; 347 348 mutex_lock(&gnss->gnss_mutex); 349 350 if (!gnss->open_count) { 351 err = -EINVAL; 352 goto exit; 353 } 354 355 cmd_buf = kcalloc(count, sizeof(*buf), GFP_KERNEL); 356 if (!cmd_buf) { 357 err = -ENOMEM; 358 goto exit; 359 } 360 361 memcpy(cmd_buf, buf, count); 362 363 /* Send the data out to a hardware port */ 364 write_buf = kzalloc(sizeof(*write_buf), GFP_KERNEL); 365 if (!write_buf) { 366 err = -ENOMEM; 367 goto exit; 368 } 369 370 write_buf->buf = cmd_buf; 371 write_buf->size = count; 372 INIT_LIST_HEAD(&write_buf->queue); 373 list_add_tail(&write_buf->queue, &gnss->queue); 374 kthread_queue_work(gnss->kworker, &gnss->write_work); 375 exit: 376 mutex_unlock(&gnss->gnss_mutex); 377 return err; 378 } 379 380 /** 381 * ice_gnss_tty_write_room - Returns the numbers of characters to be written. 382 * @tty: pointer to the tty_struct 383 * 384 * This routine returns the numbers of characters the tty driver will accept 385 * for queuing to be written or 0 if either the TTY is not open or user 386 * tries to write to the TTY other than the first. 387 */ 388 static unsigned int ice_gnss_tty_write_room(struct tty_struct *tty) 389 { 390 struct gnss_serial *gnss = tty->driver_data; 391 392 /* Only allow to write on TTY 0 */ 393 if (!gnss || gnss != gnss->back->gnss_serial[0]) 394 return 0; 395 396 mutex_lock(&gnss->gnss_mutex); 397 398 if (!gnss->open_count) { 399 mutex_unlock(&gnss->gnss_mutex); 400 return 0; 401 } 402 403 mutex_unlock(&gnss->gnss_mutex); 404 return ICE_GNSS_TTY_WRITE_BUF; 405 } 406 407 static const struct tty_operations tty_gps_ops = { 408 .open = ice_gnss_tty_open, 409 .close = ice_gnss_tty_close, 410 .write = ice_gnss_tty_write, 411 .write_room = ice_gnss_tty_write_room, 412 }; 413 414 /** 415 * ice_gnss_create_tty_driver - Create a TTY driver for GNSS 416 * @pf: Board private structure 417 */ 418 static struct tty_driver *ice_gnss_create_tty_driver(struct ice_pf *pf) 419 { 420 struct device *dev = ice_pf_to_dev(pf); 421 const int ICE_TTYDRV_NAME_MAX = 14; 422 struct tty_driver *tty_driver; 423 char *ttydrv_name; 424 unsigned int i; 425 int err; 426 427 tty_driver = tty_alloc_driver(ICE_GNSS_TTY_MINOR_DEVICES, 428 TTY_DRIVER_REAL_RAW); 429 if (IS_ERR(tty_driver)) { 430 dev_err(dev, "Failed to allocate memory for GNSS TTY\n"); 431 return NULL; 432 } 433 434 ttydrv_name = kzalloc(ICE_TTYDRV_NAME_MAX, GFP_KERNEL); 435 if (!ttydrv_name) { 436 tty_driver_kref_put(tty_driver); 437 return NULL; 438 } 439 440 snprintf(ttydrv_name, ICE_TTYDRV_NAME_MAX, "ttyGNSS_%02x%02x_", 441 (u8)pf->pdev->bus->number, (u8)PCI_SLOT(pf->pdev->devfn)); 442 443 /* Initialize the tty driver*/ 444 tty_driver->owner = THIS_MODULE; 445 tty_driver->driver_name = dev_driver_string(dev); 446 tty_driver->name = (const char *)ttydrv_name; 447 tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 448 tty_driver->subtype = SERIAL_TYPE_NORMAL; 449 tty_driver->init_termios = tty_std_termios; 450 tty_driver->init_termios.c_iflag &= ~INLCR; 451 tty_driver->init_termios.c_iflag |= IGNCR; 452 tty_driver->init_termios.c_oflag &= ~OPOST; 453 tty_driver->init_termios.c_lflag &= ~ICANON; 454 tty_driver->init_termios.c_cflag &= ~(CSIZE | CBAUD | CBAUDEX); 455 /* baud rate 9600 */ 456 tty_termios_encode_baud_rate(&tty_driver->init_termios, 9600, 9600); 457 tty_driver->driver_state = pf; 458 tty_set_operations(tty_driver, &tty_gps_ops); 459 460 for (i = 0; i < ICE_GNSS_TTY_MINOR_DEVICES; i++) { 461 pf->gnss_tty_port[i] = kzalloc(sizeof(*pf->gnss_tty_port[i]), 462 GFP_KERNEL); 463 pf->gnss_serial[i] = NULL; 464 465 tty_port_init(pf->gnss_tty_port[i]); 466 tty_port_link_device(pf->gnss_tty_port[i], tty_driver, i); 467 } 468 469 err = tty_register_driver(tty_driver); 470 if (err) { 471 dev_err(dev, "Failed to register TTY driver err=%d\n", err); 472 473 for (i = 0; i < ICE_GNSS_TTY_MINOR_DEVICES; i++) { 474 tty_port_destroy(pf->gnss_tty_port[i]); 475 kfree(pf->gnss_tty_port[i]); 476 } 477 kfree(ttydrv_name); 478 tty_driver_kref_put(pf->ice_gnss_tty_driver); 479 480 return NULL; 481 } 482 483 for (i = 0; i < ICE_GNSS_TTY_MINOR_DEVICES; i++) 484 dev_info(dev, "%s%d registered\n", ttydrv_name, i); 485 486 return tty_driver; 487 } 488 489 /** 490 * ice_gnss_init - Initialize GNSS TTY support 491 * @pf: Board private structure 492 */ 493 void ice_gnss_init(struct ice_pf *pf) 494 { 495 struct tty_driver *tty_driver; 496 497 tty_driver = ice_gnss_create_tty_driver(pf); 498 if (!tty_driver) 499 return; 500 501 pf->ice_gnss_tty_driver = tty_driver; 502 503 set_bit(ICE_FLAG_GNSS, pf->flags); 504 dev_info(ice_pf_to_dev(pf), "GNSS TTY init successful\n"); 505 } 506 507 /** 508 * ice_gnss_exit - Disable GNSS TTY support 509 * @pf: Board private structure 510 */ 511 void ice_gnss_exit(struct ice_pf *pf) 512 { 513 unsigned int i; 514 515 if (!test_bit(ICE_FLAG_GNSS, pf->flags) || !pf->ice_gnss_tty_driver) 516 return; 517 518 for (i = 0; i < ICE_GNSS_TTY_MINOR_DEVICES; i++) { 519 if (pf->gnss_tty_port[i]) { 520 tty_port_destroy(pf->gnss_tty_port[i]); 521 kfree(pf->gnss_tty_port[i]); 522 } 523 524 if (pf->gnss_serial[i]) { 525 struct gnss_serial *gnss = pf->gnss_serial[i]; 526 527 kthread_cancel_work_sync(&gnss->write_work); 528 kthread_cancel_delayed_work_sync(&gnss->read_work); 529 kfree(gnss); 530 pf->gnss_serial[i] = NULL; 531 } 532 } 533 534 tty_unregister_driver(pf->ice_gnss_tty_driver); 535 kfree(pf->ice_gnss_tty_driver->name); 536 tty_driver_kref_put(pf->ice_gnss_tty_driver); 537 pf->ice_gnss_tty_driver = NULL; 538 } 539 540 /** 541 * ice_gnss_is_gps_present - Check if GPS HW is present 542 * @hw: pointer to HW struct 543 */ 544 bool ice_gnss_is_gps_present(struct ice_hw *hw) 545 { 546 if (!hw->func_caps.ts_func_info.src_tmr_owned) 547 return false; 548 549 #if IS_ENABLED(CONFIG_PTP_1588_CLOCK) 550 if (ice_is_e810t(hw)) { 551 int err; 552 u8 data; 553 554 err = ice_read_pca9575_reg_e810t(hw, ICE_PCA9575_P0_IN, &data); 555 if (err || !!(data & ICE_E810T_P0_GNSS_PRSNT_N)) 556 return false; 557 } else { 558 return false; 559 } 560 #else 561 if (!ice_is_e810t(hw)) 562 return false; 563 #endif /* IS_ENABLED(CONFIG_PTP_1588_CLOCK) */ 564 565 return true; 566 } 567