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 */ 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 */ 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 */ 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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