]>
Commit | Line | Data |
---|---|---|
0c9bd600 JZHPH |
1 | /* |
2 | * F81532/F81534 USB to Serial Ports Bridge | |
3 | * | |
4 | * F81532 => 2 Serial Ports | |
5 | * F81534 => 4 Serial Ports | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * Copyright (C) 2016 Feature Integration Technology Inc., (Fintek) | |
13 | * Copyright (C) 2016 Tom Tsai (Tom_Tsai@fintek.com.tw) | |
14 | * Copyright (C) 2016 Peter Hong (Peter_Hong@fintek.com.tw) | |
15 | * | |
16 | * The F81532/F81534 had 1 control endpoint for setting, 1 endpoint bulk-out | |
17 | * for all serial port TX and 1 endpoint bulk-in for all serial port read in | |
18 | * (Read Data/MSR/LSR). | |
19 | * | |
20 | * Write URB is fixed with 512bytes, per serial port used 128Bytes. | |
21 | * It can be described by f81534_prepare_write_buffer() | |
22 | * | |
23 | * Read URB is 512Bytes max, per serial port used 128Bytes. | |
24 | * It can be described by f81534_process_read_urb() and maybe received with | |
25 | * 128x1,2,3,4 bytes. | |
26 | * | |
27 | */ | |
28 | #include <linux/slab.h> | |
29 | #include <linux/tty.h> | |
30 | #include <linux/tty_flip.h> | |
31 | #include <linux/usb.h> | |
32 | #include <linux/usb/serial.h> | |
33 | #include <linux/serial_reg.h> | |
34 | #include <linux/module.h> | |
35 | #include <linux/uaccess.h> | |
36 | ||
37 | /* Serial Port register Address */ | |
38 | #define F81534_UART_BASE_ADDRESS 0x1200 | |
39 | #define F81534_UART_OFFSET 0x10 | |
40 | #define F81534_DIVISOR_LSB_REG (0x00 + F81534_UART_BASE_ADDRESS) | |
41 | #define F81534_DIVISOR_MSB_REG (0x01 + F81534_UART_BASE_ADDRESS) | |
42 | #define F81534_FIFO_CONTROL_REG (0x02 + F81534_UART_BASE_ADDRESS) | |
43 | #define F81534_LINE_CONTROL_REG (0x03 + F81534_UART_BASE_ADDRESS) | |
44 | #define F81534_MODEM_CONTROL_REG (0x04 + F81534_UART_BASE_ADDRESS) | |
45 | #define F81534_MODEM_STATUS_REG (0x06 + F81534_UART_BASE_ADDRESS) | |
46 | #define F81534_CONFIG1_REG (0x09 + F81534_UART_BASE_ADDRESS) | |
47 | ||
48 | #define F81534_DEF_CONF_ADDRESS_START 0x3000 | |
49 | #define F81534_DEF_CONF_SIZE 8 | |
50 | ||
51 | #define F81534_CUSTOM_ADDRESS_START 0x2f00 | |
52 | #define F81534_CUSTOM_DATA_SIZE 0x10 | |
53 | #define F81534_CUSTOM_NO_CUSTOM_DATA 0xff | |
54 | #define F81534_CUSTOM_VALID_TOKEN 0xf0 | |
55 | #define F81534_CONF_OFFSET 1 | |
56 | ||
57 | #define F81534_MAX_DATA_BLOCK 64 | |
58 | #define F81534_MAX_BUS_RETRY 20 | |
59 | ||
60 | /* Default URB timeout for USB operations */ | |
61 | #define F81534_USB_MAX_RETRY 10 | |
62 | #define F81534_USB_TIMEOUT 1000 | |
63 | #define F81534_SET_GET_REGISTER 0xA0 | |
64 | ||
65 | #define F81534_NUM_PORT 4 | |
66 | #define F81534_UNUSED_PORT 0xff | |
67 | #define F81534_WRITE_BUFFER_SIZE 512 | |
68 | ||
69 | #define DRIVER_DESC "Fintek F81532/F81534" | |
70 | #define FINTEK_VENDOR_ID_1 0x1934 | |
71 | #define FINTEK_VENDOR_ID_2 0x2C42 | |
72 | #define FINTEK_DEVICE_ID 0x1202 | |
73 | #define F81534_MAX_TX_SIZE 124 | |
74 | #define F81534_MAX_RX_SIZE 124 | |
75 | #define F81534_RECEIVE_BLOCK_SIZE 128 | |
76 | #define F81534_MAX_RECEIVE_BLOCK_SIZE 512 | |
77 | ||
78 | #define F81534_TOKEN_RECEIVE 0x01 | |
79 | #define F81534_TOKEN_WRITE 0x02 | |
80 | #define F81534_TOKEN_TX_EMPTY 0x03 | |
81 | #define F81534_TOKEN_MSR_CHANGE 0x04 | |
82 | ||
83 | /* | |
84 | * We used interal SPI bus to access FLASH section. We must wait the SPI bus to | |
85 | * idle if we performed any command. | |
86 | * | |
87 | * SPI Bus status register: F81534_BUS_REG_STATUS | |
88 | * Bit 0/1 : BUSY | |
89 | * Bit 2 : IDLE | |
90 | */ | |
91 | #define F81534_BUS_BUSY (BIT(0) | BIT(1)) | |
92 | #define F81534_BUS_IDLE BIT(2) | |
93 | #define F81534_BUS_READ_DATA 0x1004 | |
94 | #define F81534_BUS_REG_STATUS 0x1003 | |
95 | #define F81534_BUS_REG_START 0x1002 | |
96 | #define F81534_BUS_REG_END 0x1001 | |
97 | ||
98 | #define F81534_CMD_READ 0x03 | |
99 | ||
100 | #define F81534_DEFAULT_BAUD_RATE 9600 | |
101 | #define F81534_MAX_BAUDRATE 115200 | |
102 | ||
103 | #define F81534_PORT_CONF_DISABLE_PORT BIT(3) | |
104 | #define F81534_PORT_CONF_NOT_EXIST_PORT BIT(7) | |
105 | #define F81534_PORT_UNAVAILABLE \ | |
106 | (F81534_PORT_CONF_DISABLE_PORT | F81534_PORT_CONF_NOT_EXIST_PORT) | |
107 | ||
108 | #define F81534_1X_RXTRIGGER 0xc3 | |
109 | #define F81534_8X_RXTRIGGER 0xcf | |
110 | ||
111 | static const struct usb_device_id f81534_id_table[] = { | |
112 | { USB_DEVICE(FINTEK_VENDOR_ID_1, FINTEK_DEVICE_ID) }, | |
113 | { USB_DEVICE(FINTEK_VENDOR_ID_2, FINTEK_DEVICE_ID) }, | |
114 | {} /* Terminating entry */ | |
115 | }; | |
116 | ||
117 | #define F81534_TX_EMPTY_BIT 0 | |
118 | ||
119 | struct f81534_serial_private { | |
120 | u8 conf_data[F81534_DEF_CONF_SIZE]; | |
121 | int tty_idx[F81534_NUM_PORT]; | |
122 | u8 setting_idx; | |
123 | int opened_port; | |
124 | struct mutex urb_mutex; | |
125 | }; | |
126 | ||
127 | struct f81534_port_private { | |
128 | struct mutex mcr_mutex; | |
129 | unsigned long tx_empty; | |
130 | spinlock_t msr_lock; | |
131 | u8 shadow_mcr; | |
132 | u8 shadow_msr; | |
133 | u8 phy_num; | |
134 | }; | |
135 | ||
136 | static int f81534_logic_to_phy_port(struct usb_serial *serial, | |
137 | struct usb_serial_port *port) | |
138 | { | |
139 | struct f81534_serial_private *serial_priv = | |
140 | usb_get_serial_data(port->serial); | |
141 | int count = 0; | |
142 | int i; | |
143 | ||
144 | for (i = 0; i < F81534_NUM_PORT; ++i) { | |
145 | if (serial_priv->conf_data[i] & F81534_PORT_UNAVAILABLE) | |
146 | continue; | |
147 | ||
148 | if (port->port_number == count) | |
149 | return i; | |
150 | ||
151 | ++count; | |
152 | } | |
153 | ||
154 | return -ENODEV; | |
155 | } | |
156 | ||
157 | static int f81534_set_register(struct usb_serial *serial, u16 reg, u8 data) | |
158 | { | |
159 | struct usb_interface *interface = serial->interface; | |
160 | struct usb_device *dev = serial->dev; | |
161 | size_t count = F81534_USB_MAX_RETRY; | |
162 | int status; | |
163 | u8 *tmp; | |
164 | ||
165 | tmp = kmalloc(sizeof(u8), GFP_KERNEL); | |
166 | if (!tmp) | |
167 | return -ENOMEM; | |
168 | ||
169 | *tmp = data; | |
170 | ||
171 | /* | |
172 | * Our device maybe not reply when heavily loading, We'll retry for | |
173 | * F81534_USB_MAX_RETRY times. | |
174 | */ | |
175 | while (count--) { | |
176 | status = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), | |
177 | F81534_SET_GET_REGISTER, | |
178 | USB_TYPE_VENDOR | USB_DIR_OUT, | |
179 | reg, 0, tmp, sizeof(u8), | |
180 | F81534_USB_TIMEOUT); | |
181 | if (status > 0) { | |
182 | status = 0; | |
183 | break; | |
184 | } else if (status == 0) { | |
185 | status = -EIO; | |
186 | } | |
187 | } | |
188 | ||
189 | if (status < 0) { | |
190 | dev_err(&interface->dev, "%s: reg: %x data: %x failed: %d\n", | |
191 | __func__, reg, data, status); | |
192 | } | |
193 | ||
194 | kfree(tmp); | |
195 | return status; | |
196 | } | |
197 | ||
198 | static int f81534_get_register(struct usb_serial *serial, u16 reg, u8 *data) | |
199 | { | |
200 | struct usb_interface *interface = serial->interface; | |
201 | struct usb_device *dev = serial->dev; | |
202 | size_t count = F81534_USB_MAX_RETRY; | |
203 | int status; | |
204 | u8 *tmp; | |
205 | ||
206 | tmp = kmalloc(sizeof(u8), GFP_KERNEL); | |
207 | if (!tmp) | |
208 | return -ENOMEM; | |
209 | ||
210 | /* | |
211 | * Our device maybe not reply when heavily loading, We'll retry for | |
212 | * F81534_USB_MAX_RETRY times. | |
213 | */ | |
214 | while (count--) { | |
215 | status = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), | |
216 | F81534_SET_GET_REGISTER, | |
217 | USB_TYPE_VENDOR | USB_DIR_IN, | |
218 | reg, 0, tmp, sizeof(u8), | |
219 | F81534_USB_TIMEOUT); | |
220 | if (status > 0) { | |
221 | status = 0; | |
222 | break; | |
223 | } else if (status == 0) { | |
224 | status = -EIO; | |
225 | } | |
226 | } | |
227 | ||
228 | if (status < 0) { | |
229 | dev_err(&interface->dev, "%s: reg: %x failed: %d\n", __func__, | |
230 | reg, status); | |
231 | goto end; | |
232 | } | |
233 | ||
234 | *data = *tmp; | |
235 | ||
236 | end: | |
237 | kfree(tmp); | |
238 | return status; | |
239 | } | |
240 | ||
241 | static int f81534_set_port_register(struct usb_serial_port *port, u16 reg, | |
242 | u8 data) | |
243 | { | |
244 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
245 | ||
246 | return f81534_set_register(port->serial, | |
247 | reg + port_priv->phy_num * F81534_UART_OFFSET, data); | |
248 | } | |
249 | ||
250 | static int f81534_get_port_register(struct usb_serial_port *port, u16 reg, | |
251 | u8 *data) | |
252 | { | |
253 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
254 | ||
255 | return f81534_get_register(port->serial, | |
256 | reg + port_priv->phy_num * F81534_UART_OFFSET, data); | |
257 | } | |
258 | ||
259 | /* | |
260 | * If we try to access the internal flash via SPI bus, we should check the bus | |
261 | * status for every command. e.g., F81534_BUS_REG_START/F81534_BUS_REG_END | |
262 | */ | |
263 | static int f81534_wait_for_spi_idle(struct usb_serial *serial) | |
264 | { | |
265 | size_t count = F81534_MAX_BUS_RETRY; | |
266 | u8 tmp; | |
267 | int status; | |
268 | ||
269 | do { | |
270 | status = f81534_get_register(serial, F81534_BUS_REG_STATUS, | |
271 | &tmp); | |
272 | if (status) | |
273 | return status; | |
274 | ||
275 | if (tmp & F81534_BUS_BUSY) | |
276 | continue; | |
277 | ||
278 | if (tmp & F81534_BUS_IDLE) | |
279 | break; | |
280 | ||
281 | } while (--count); | |
282 | ||
283 | if (!count) { | |
284 | dev_err(&serial->interface->dev, | |
285 | "%s: timed out waiting for idle SPI bus\n", | |
286 | __func__); | |
287 | return -EIO; | |
288 | } | |
289 | ||
290 | return f81534_set_register(serial, F81534_BUS_REG_STATUS, | |
291 | tmp & ~F81534_BUS_IDLE); | |
292 | } | |
293 | ||
294 | static int f81534_get_spi_register(struct usb_serial *serial, u16 reg, | |
295 | u8 *data) | |
296 | { | |
297 | int status; | |
298 | ||
299 | status = f81534_get_register(serial, reg, data); | |
300 | if (status) | |
301 | return status; | |
302 | ||
303 | return f81534_wait_for_spi_idle(serial); | |
304 | } | |
305 | ||
306 | static int f81534_set_spi_register(struct usb_serial *serial, u16 reg, u8 data) | |
307 | { | |
308 | int status; | |
309 | ||
310 | status = f81534_set_register(serial, reg, data); | |
311 | if (status) | |
312 | return status; | |
313 | ||
314 | return f81534_wait_for_spi_idle(serial); | |
315 | } | |
316 | ||
317 | static int f81534_read_flash(struct usb_serial *serial, u32 address, | |
318 | size_t size, u8 *buf) | |
319 | { | |
320 | u8 tmp_buf[F81534_MAX_DATA_BLOCK]; | |
321 | size_t block = 0; | |
322 | size_t read_size; | |
323 | size_t count; | |
324 | int status; | |
325 | int offset; | |
326 | u16 reg_tmp; | |
327 | ||
328 | status = f81534_set_spi_register(serial, F81534_BUS_REG_START, | |
329 | F81534_CMD_READ); | |
330 | if (status) | |
331 | return status; | |
332 | ||
333 | status = f81534_set_spi_register(serial, F81534_BUS_REG_START, | |
334 | (address >> 16) & 0xff); | |
335 | if (status) | |
336 | return status; | |
337 | ||
338 | status = f81534_set_spi_register(serial, F81534_BUS_REG_START, | |
339 | (address >> 8) & 0xff); | |
340 | if (status) | |
341 | return status; | |
342 | ||
343 | status = f81534_set_spi_register(serial, F81534_BUS_REG_START, | |
344 | (address >> 0) & 0xff); | |
345 | if (status) | |
346 | return status; | |
347 | ||
348 | /* Continuous read mode */ | |
349 | do { | |
350 | read_size = min_t(size_t, F81534_MAX_DATA_BLOCK, size); | |
351 | ||
352 | for (count = 0; count < read_size; ++count) { | |
353 | /* To write F81534_BUS_REG_END when final byte */ | |
354 | if (size <= F81534_MAX_DATA_BLOCK && | |
355 | read_size == count + 1) | |
356 | reg_tmp = F81534_BUS_REG_END; | |
357 | else | |
358 | reg_tmp = F81534_BUS_REG_START; | |
359 | ||
360 | /* | |
361 | * Dummy code, force IC to generate a read pulse, the | |
362 | * set of value 0xf1 is dont care (any value is ok) | |
363 | */ | |
364 | status = f81534_set_spi_register(serial, reg_tmp, | |
365 | 0xf1); | |
366 | if (status) | |
367 | return status; | |
368 | ||
369 | status = f81534_get_spi_register(serial, | |
370 | F81534_BUS_READ_DATA, | |
371 | &tmp_buf[count]); | |
372 | if (status) | |
373 | return status; | |
374 | ||
375 | offset = count + block * F81534_MAX_DATA_BLOCK; | |
376 | buf[offset] = tmp_buf[count]; | |
377 | } | |
378 | ||
379 | size -= read_size; | |
380 | ++block; | |
381 | } while (size); | |
382 | ||
383 | return 0; | |
384 | } | |
385 | ||
386 | static void f81534_prepare_write_buffer(struct usb_serial_port *port, u8 *buf) | |
387 | { | |
388 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
389 | int phy_num = port_priv->phy_num; | |
390 | u8 tx_len; | |
391 | int i; | |
392 | ||
393 | /* | |
394 | * The block layout is fixed with 4x128 Bytes, per 128 Bytes a port. | |
395 | * index 0: port phy idx (e.g., 0,1,2,3) | |
396 | * index 1: only F81534_TOKEN_WRITE | |
397 | * index 2: serial TX out length | |
398 | * index 3: fix to 0 | |
399 | * index 4~127: serial out data block | |
400 | */ | |
401 | for (i = 0; i < F81534_NUM_PORT; ++i) { | |
402 | buf[i * F81534_RECEIVE_BLOCK_SIZE] = i; | |
403 | buf[i * F81534_RECEIVE_BLOCK_SIZE + 1] = F81534_TOKEN_WRITE; | |
404 | buf[i * F81534_RECEIVE_BLOCK_SIZE + 2] = 0; | |
405 | buf[i * F81534_RECEIVE_BLOCK_SIZE + 3] = 0; | |
406 | } | |
407 | ||
408 | tx_len = kfifo_out_locked(&port->write_fifo, | |
409 | &buf[phy_num * F81534_RECEIVE_BLOCK_SIZE + 4], | |
410 | F81534_MAX_TX_SIZE, &port->lock); | |
411 | ||
412 | buf[phy_num * F81534_RECEIVE_BLOCK_SIZE + 2] = tx_len; | |
413 | } | |
414 | ||
415 | static int f81534_submit_writer(struct usb_serial_port *port, gfp_t mem_flags) | |
416 | { | |
417 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
418 | struct urb *urb; | |
419 | unsigned long flags; | |
420 | int result; | |
421 | ||
422 | /* Check is any data in write_fifo */ | |
423 | spin_lock_irqsave(&port->lock, flags); | |
424 | ||
425 | if (kfifo_is_empty(&port->write_fifo)) { | |
426 | spin_unlock_irqrestore(&port->lock, flags); | |
427 | return 0; | |
428 | } | |
429 | ||
430 | spin_unlock_irqrestore(&port->lock, flags); | |
431 | ||
432 | /* Check H/W is TXEMPTY */ | |
433 | if (!test_and_clear_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty)) | |
434 | return 0; | |
435 | ||
436 | urb = port->write_urbs[0]; | |
437 | f81534_prepare_write_buffer(port, port->bulk_out_buffers[0]); | |
438 | urb->transfer_buffer_length = F81534_WRITE_BUFFER_SIZE; | |
439 | ||
440 | result = usb_submit_urb(urb, mem_flags); | |
441 | if (result) { | |
442 | set_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty); | |
443 | dev_err(&port->dev, "%s: submit failed: %d\n", __func__, | |
444 | result); | |
445 | return result; | |
446 | } | |
447 | ||
448 | usb_serial_port_softint(port); | |
449 | return 0; | |
450 | } | |
451 | ||
452 | static u32 f81534_calc_baud_divisor(u32 baudrate, u32 clockrate) | |
453 | { | |
454 | if (!baudrate) | |
455 | return 0; | |
456 | ||
457 | /* Round to nearest divisor */ | |
458 | return DIV_ROUND_CLOSEST(clockrate, baudrate); | |
459 | } | |
460 | ||
461 | static int f81534_set_port_config(struct usb_serial_port *port, u32 baudrate, | |
462 | u8 lcr) | |
463 | { | |
464 | u32 divisor; | |
465 | int status; | |
466 | u8 value; | |
467 | ||
468 | if (baudrate <= 1200) | |
469 | value = F81534_1X_RXTRIGGER; /* 128 FIFO & TL: 1x */ | |
470 | else | |
471 | value = F81534_8X_RXTRIGGER; /* 128 FIFO & TL: 8x */ | |
472 | ||
473 | status = f81534_set_port_register(port, F81534_CONFIG1_REG, value); | |
474 | if (status) { | |
475 | dev_err(&port->dev, "%s: CONFIG1 setting failed\n", __func__); | |
476 | return status; | |
477 | } | |
478 | ||
479 | if (baudrate <= 1200) | |
480 | value = UART_FCR_TRIGGER_1 | UART_FCR_ENABLE_FIFO; /* TL: 1 */ | |
481 | else | |
482 | value = UART_FCR_R_TRIG_11 | UART_FCR_ENABLE_FIFO; /* TL: 14 */ | |
483 | ||
484 | status = f81534_set_port_register(port, F81534_FIFO_CONTROL_REG, | |
485 | value); | |
486 | if (status) { | |
487 | dev_err(&port->dev, "%s: FCR setting failed\n", __func__); | |
488 | return status; | |
489 | } | |
490 | ||
491 | divisor = f81534_calc_baud_divisor(baudrate, F81534_MAX_BAUDRATE); | |
492 | value = UART_LCR_DLAB; | |
493 | status = f81534_set_port_register(port, F81534_LINE_CONTROL_REG, | |
494 | value); | |
495 | if (status) { | |
496 | dev_err(&port->dev, "%s: set LCR failed\n", __func__); | |
497 | return status; | |
498 | } | |
499 | ||
500 | value = divisor & 0xff; | |
501 | status = f81534_set_port_register(port, F81534_DIVISOR_LSB_REG, value); | |
502 | if (status) { | |
503 | dev_err(&port->dev, "%s: set DLAB LSB failed\n", __func__); | |
504 | return status; | |
505 | } | |
506 | ||
507 | value = (divisor >> 8) & 0xff; | |
508 | status = f81534_set_port_register(port, F81534_DIVISOR_MSB_REG, value); | |
509 | if (status) { | |
510 | dev_err(&port->dev, "%s: set DLAB MSB failed\n", __func__); | |
511 | return status; | |
512 | } | |
513 | ||
514 | status = f81534_set_port_register(port, F81534_LINE_CONTROL_REG, lcr); | |
515 | if (status) { | |
516 | dev_err(&port->dev, "%s: set LCR failed\n", __func__); | |
517 | return status; | |
518 | } | |
519 | ||
520 | return 0; | |
521 | } | |
522 | ||
523 | static int f81534_update_mctrl(struct usb_serial_port *port, unsigned int set, | |
524 | unsigned int clear) | |
525 | { | |
526 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
527 | int status; | |
528 | u8 tmp; | |
529 | ||
530 | if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) | |
531 | return 0; /* no change */ | |
532 | ||
533 | mutex_lock(&port_priv->mcr_mutex); | |
534 | ||
535 | /* 'Set' takes precedence over 'Clear' */ | |
536 | clear &= ~set; | |
537 | ||
538 | /* Always enable UART_MCR_OUT2 */ | |
539 | tmp = UART_MCR_OUT2 | port_priv->shadow_mcr; | |
540 | ||
541 | if (clear & TIOCM_DTR) | |
542 | tmp &= ~UART_MCR_DTR; | |
543 | ||
544 | if (clear & TIOCM_RTS) | |
545 | tmp &= ~UART_MCR_RTS; | |
546 | ||
547 | if (set & TIOCM_DTR) | |
548 | tmp |= UART_MCR_DTR; | |
549 | ||
550 | if (set & TIOCM_RTS) | |
551 | tmp |= UART_MCR_RTS; | |
552 | ||
553 | status = f81534_set_port_register(port, F81534_MODEM_CONTROL_REG, tmp); | |
554 | if (status < 0) { | |
555 | dev_err(&port->dev, "%s: MCR write failed\n", __func__); | |
556 | mutex_unlock(&port_priv->mcr_mutex); | |
557 | return status; | |
558 | } | |
559 | ||
560 | port_priv->shadow_mcr = tmp; | |
561 | mutex_unlock(&port_priv->mcr_mutex); | |
562 | return 0; | |
563 | } | |
564 | ||
565 | /* | |
566 | * This function will search the data area with token F81534_CUSTOM_VALID_TOKEN | |
567 | * for latest configuration index. If nothing found | |
568 | * (*index = F81534_CUSTOM_NO_CUSTOM_DATA), We'll load default configure in | |
569 | * F81534_DEF_CONF_ADDRESS_START section. | |
570 | * | |
571 | * Due to we only use block0 to save data, so *index should be 0 or | |
572 | * F81534_CUSTOM_NO_CUSTOM_DATA. | |
573 | */ | |
574 | static int f81534_find_config_idx(struct usb_serial *serial, u8 *index) | |
575 | { | |
576 | u8 tmp; | |
577 | int status; | |
578 | ||
579 | status = f81534_read_flash(serial, F81534_CUSTOM_ADDRESS_START, 1, | |
580 | &tmp); | |
581 | if (status) { | |
582 | dev_err(&serial->interface->dev, "%s: read failed: %d\n", | |
583 | __func__, status); | |
584 | return status; | |
585 | } | |
586 | ||
587 | /* We'll use the custom data when the data is valid. */ | |
588 | if (tmp == F81534_CUSTOM_VALID_TOKEN) | |
589 | *index = 0; | |
590 | else | |
591 | *index = F81534_CUSTOM_NO_CUSTOM_DATA; | |
592 | ||
593 | return 0; | |
594 | } | |
595 | ||
596 | /* | |
597 | * We had 2 generation of F81532/534 IC. All has an internal storage. | |
598 | * | |
599 | * 1st is pure USB-to-TTL RS232 IC and designed for 4 ports only, no any | |
600 | * internal data will used. All mode and gpio control should manually set | |
601 | * by AP or Driver and all storage space value are 0xff. The | |
602 | * f81534_calc_num_ports() will run to final we marked as "oldest version" | |
603 | * for this IC. | |
604 | * | |
605 | * 2rd is designed to more generic to use any transceiver and this is our | |
606 | * mass production type. We'll save data in F81534_CUSTOM_ADDRESS_START | |
607 | * (0x2f00) with 9bytes. The 1st byte is a indicater. If the token is | |
608 | * F81534_CUSTOM_VALID_TOKEN(0xf0), the IC is 2nd gen type, the following | |
609 | * 4bytes save port mode (0:RS232/1:RS485 Invert/2:RS485), and the last | |
610 | * 4bytes save GPIO state(value from 0~7 to represent 3 GPIO output pin). | |
611 | * The f81534_calc_num_ports() will run to "new style" with checking | |
612 | * F81534_PORT_UNAVAILABLE section. | |
613 | */ | |
614 | static int f81534_calc_num_ports(struct usb_serial *serial) | |
615 | { | |
616 | u8 setting[F81534_CUSTOM_DATA_SIZE]; | |
617 | u8 setting_idx; | |
618 | u8 num_port = 0; | |
619 | int status; | |
620 | size_t i; | |
621 | ||
622 | /* Check had custom setting */ | |
623 | status = f81534_find_config_idx(serial, &setting_idx); | |
624 | if (status) { | |
625 | dev_err(&serial->interface->dev, "%s: find idx failed: %d\n", | |
626 | __func__, status); | |
627 | return 0; | |
628 | } | |
629 | ||
630 | /* | |
631 | * We'll read custom data only when data available, otherwise we'll | |
632 | * read default value instead. | |
633 | */ | |
634 | if (setting_idx != F81534_CUSTOM_NO_CUSTOM_DATA) { | |
635 | status = f81534_read_flash(serial, | |
636 | F81534_CUSTOM_ADDRESS_START + | |
637 | F81534_CONF_OFFSET, | |
638 | sizeof(setting), setting); | |
639 | if (status) { | |
640 | dev_err(&serial->interface->dev, | |
641 | "%s: get custom data failed: %d\n", | |
642 | __func__, status); | |
643 | return 0; | |
644 | } | |
645 | ||
646 | dev_dbg(&serial->interface->dev, | |
647 | "%s: read config from block: %d\n", __func__, | |
648 | setting_idx); | |
649 | } else { | |
650 | /* Read default board setting */ | |
651 | status = f81534_read_flash(serial, | |
652 | F81534_DEF_CONF_ADDRESS_START, F81534_NUM_PORT, | |
653 | setting); | |
654 | ||
655 | if (status) { | |
656 | dev_err(&serial->interface->dev, | |
657 | "%s: read failed: %d\n", __func__, | |
658 | status); | |
659 | return 0; | |
660 | } | |
661 | ||
662 | dev_dbg(&serial->interface->dev, "%s: read default config\n", | |
663 | __func__); | |
664 | } | |
665 | ||
666 | /* New style, find all possible ports */ | |
667 | for (i = 0; i < F81534_NUM_PORT; ++i) { | |
668 | if (setting[i] & F81534_PORT_UNAVAILABLE) | |
669 | continue; | |
670 | ||
671 | ++num_port; | |
672 | } | |
673 | ||
674 | if (num_port) | |
675 | return num_port; | |
676 | ||
677 | dev_warn(&serial->interface->dev, "%s: Read Failed. default 4 ports\n", | |
678 | __func__); | |
679 | return 4; /* Nothing found, oldest version IC */ | |
680 | } | |
681 | ||
682 | static void f81534_set_termios(struct tty_struct *tty, | |
683 | struct usb_serial_port *port, | |
684 | struct ktermios *old_termios) | |
685 | { | |
686 | u8 new_lcr = 0; | |
687 | int status; | |
688 | u32 baud; | |
689 | ||
690 | if (C_BAUD(tty) == B0) | |
691 | f81534_update_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS); | |
692 | else if (old_termios && (old_termios->c_cflag & CBAUD) == B0) | |
693 | f81534_update_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0); | |
694 | ||
695 | if (C_PARENB(tty)) { | |
696 | new_lcr |= UART_LCR_PARITY; | |
697 | ||
698 | if (!C_PARODD(tty)) | |
699 | new_lcr |= UART_LCR_EPAR; | |
700 | ||
701 | if (C_CMSPAR(tty)) | |
702 | new_lcr |= UART_LCR_SPAR; | |
703 | } | |
704 | ||
705 | if (C_CSTOPB(tty)) | |
706 | new_lcr |= UART_LCR_STOP; | |
707 | ||
708 | switch (C_CSIZE(tty)) { | |
709 | case CS5: | |
710 | new_lcr |= UART_LCR_WLEN5; | |
711 | break; | |
712 | case CS6: | |
713 | new_lcr |= UART_LCR_WLEN6; | |
714 | break; | |
715 | case CS7: | |
716 | new_lcr |= UART_LCR_WLEN7; | |
717 | break; | |
718 | default: | |
719 | case CS8: | |
720 | new_lcr |= UART_LCR_WLEN8; | |
721 | break; | |
722 | } | |
723 | ||
724 | baud = tty_get_baud_rate(tty); | |
725 | if (!baud) | |
726 | return; | |
727 | ||
728 | if (baud > F81534_MAX_BAUDRATE) { | |
729 | if (old_termios) | |
730 | baud = tty_termios_baud_rate(old_termios); | |
731 | else | |
732 | baud = F81534_DEFAULT_BAUD_RATE; | |
733 | ||
734 | tty_encode_baud_rate(tty, baud, baud); | |
735 | } | |
736 | ||
737 | dev_dbg(&port->dev, "%s: baud: %d\n", __func__, baud); | |
738 | ||
739 | status = f81534_set_port_config(port, baud, new_lcr); | |
740 | if (status < 0) { | |
741 | dev_err(&port->dev, "%s: set port config failed: %d\n", | |
742 | __func__, status); | |
743 | } | |
744 | } | |
745 | ||
746 | static int f81534_submit_read_urb(struct usb_serial *serial, gfp_t flags) | |
747 | { | |
748 | return usb_serial_generic_submit_read_urbs(serial->port[0], flags); | |
749 | } | |
750 | ||
751 | static void f81534_msr_changed(struct usb_serial_port *port, u8 msr) | |
752 | { | |
753 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
754 | struct tty_struct *tty; | |
755 | unsigned long flags; | |
756 | u8 old_msr; | |
757 | ||
758 | if (!(msr & UART_MSR_ANY_DELTA)) | |
759 | return; | |
760 | ||
761 | spin_lock_irqsave(&port_priv->msr_lock, flags); | |
762 | old_msr = port_priv->shadow_msr; | |
763 | port_priv->shadow_msr = msr; | |
764 | spin_unlock_irqrestore(&port_priv->msr_lock, flags); | |
765 | ||
766 | dev_dbg(&port->dev, "%s: MSR from %02x to %02x\n", __func__, old_msr, | |
767 | msr); | |
768 | ||
769 | /* Update input line counters */ | |
770 | if (msr & UART_MSR_DCTS) | |
771 | port->icount.cts++; | |
772 | if (msr & UART_MSR_DDSR) | |
773 | port->icount.dsr++; | |
774 | if (msr & UART_MSR_DDCD) | |
775 | port->icount.dcd++; | |
776 | if (msr & UART_MSR_TERI) | |
777 | port->icount.rng++; | |
778 | ||
779 | wake_up_interruptible(&port->port.delta_msr_wait); | |
780 | ||
781 | if (!(msr & UART_MSR_DDCD)) | |
782 | return; | |
783 | ||
784 | dev_dbg(&port->dev, "%s: DCD Changed: phy_num: %d from %x to %x\n", | |
785 | __func__, port_priv->phy_num, old_msr, msr); | |
786 | ||
787 | tty = tty_port_tty_get(&port->port); | |
788 | if (!tty) | |
789 | return; | |
790 | ||
791 | usb_serial_handle_dcd_change(port, tty, msr & UART_MSR_DCD); | |
792 | tty_kref_put(tty); | |
793 | } | |
794 | ||
795 | static int f81534_read_msr(struct usb_serial_port *port) | |
796 | { | |
797 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
798 | unsigned long flags; | |
799 | int status; | |
800 | u8 msr; | |
801 | ||
802 | /* Get MSR initial value */ | |
803 | status = f81534_get_port_register(port, F81534_MODEM_STATUS_REG, &msr); | |
804 | if (status) | |
805 | return status; | |
806 | ||
807 | /* Force update current state */ | |
808 | spin_lock_irqsave(&port_priv->msr_lock, flags); | |
809 | port_priv->shadow_msr = msr; | |
810 | spin_unlock_irqrestore(&port_priv->msr_lock, flags); | |
811 | ||
812 | return 0; | |
813 | } | |
814 | ||
815 | static int f81534_open(struct tty_struct *tty, struct usb_serial_port *port) | |
816 | { | |
817 | struct f81534_serial_private *serial_priv = | |
818 | usb_get_serial_data(port->serial); | |
819 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
820 | int status; | |
821 | ||
822 | status = f81534_set_port_register(port, | |
823 | F81534_FIFO_CONTROL_REG, UART_FCR_ENABLE_FIFO | | |
824 | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT); | |
825 | if (status) { | |
826 | dev_err(&port->dev, "%s: Clear FIFO failed: %d\n", __func__, | |
827 | status); | |
828 | return status; | |
829 | } | |
830 | ||
831 | if (tty) | |
832 | f81534_set_termios(tty, port, NULL); | |
833 | ||
834 | status = f81534_read_msr(port); | |
835 | if (status) | |
836 | return status; | |
837 | ||
838 | mutex_lock(&serial_priv->urb_mutex); | |
839 | ||
840 | /* Submit Read URBs for first port opened */ | |
841 | if (!serial_priv->opened_port) { | |
842 | status = f81534_submit_read_urb(port->serial, GFP_KERNEL); | |
843 | if (status) | |
844 | goto exit; | |
845 | } | |
846 | ||
847 | serial_priv->opened_port++; | |
848 | ||
849 | exit: | |
850 | mutex_unlock(&serial_priv->urb_mutex); | |
851 | ||
852 | set_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty); | |
853 | return status; | |
854 | } | |
855 | ||
856 | static void f81534_close(struct usb_serial_port *port) | |
857 | { | |
858 | struct f81534_serial_private *serial_priv = | |
859 | usb_get_serial_data(port->serial); | |
860 | struct usb_serial_port *port0 = port->serial->port[0]; | |
861 | unsigned long flags; | |
862 | size_t i; | |
863 | ||
864 | usb_kill_urb(port->write_urbs[0]); | |
865 | ||
866 | spin_lock_irqsave(&port->lock, flags); | |
867 | kfifo_reset_out(&port->write_fifo); | |
868 | spin_unlock_irqrestore(&port->lock, flags); | |
869 | ||
870 | /* Kill Read URBs when final port closed */ | |
871 | mutex_lock(&serial_priv->urb_mutex); | |
872 | serial_priv->opened_port--; | |
873 | ||
874 | if (!serial_priv->opened_port) { | |
875 | for (i = 0; i < ARRAY_SIZE(port0->read_urbs); ++i) | |
876 | usb_kill_urb(port0->read_urbs[i]); | |
877 | } | |
878 | ||
879 | mutex_unlock(&serial_priv->urb_mutex); | |
880 | } | |
881 | ||
882 | static int f81534_get_serial_info(struct usb_serial_port *port, | |
883 | struct serial_struct __user *retinfo) | |
884 | { | |
885 | struct f81534_port_private *port_priv; | |
886 | struct serial_struct tmp; | |
887 | ||
888 | port_priv = usb_get_serial_port_data(port); | |
889 | ||
890 | memset(&tmp, 0, sizeof(tmp)); | |
891 | ||
892 | tmp.type = PORT_16550A; | |
893 | tmp.port = port->port_number; | |
894 | tmp.line = port->minor; | |
895 | tmp.baud_base = F81534_MAX_BAUDRATE; | |
896 | ||
897 | if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) | |
898 | return -EFAULT; | |
899 | ||
900 | return 0; | |
901 | } | |
902 | ||
903 | static int f81534_ioctl(struct tty_struct *tty, unsigned int cmd, | |
904 | unsigned long arg) | |
905 | { | |
906 | struct usb_serial_port *port = tty->driver_data; | |
907 | struct serial_struct __user *buf = (struct serial_struct __user *)arg; | |
908 | ||
909 | switch (cmd) { | |
910 | case TIOCGSERIAL: | |
911 | return f81534_get_serial_info(port, buf); | |
912 | default: | |
913 | break; | |
914 | } | |
915 | ||
916 | return -ENOIOCTLCMD; | |
917 | } | |
918 | ||
919 | static void f81534_process_per_serial_block(struct usb_serial_port *port, | |
920 | u8 *data) | |
921 | { | |
922 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
923 | int phy_num = data[0]; | |
924 | size_t read_size = 0; | |
925 | size_t i; | |
926 | char tty_flag; | |
927 | int status; | |
928 | u8 lsr; | |
929 | ||
930 | /* | |
931 | * The block layout is 128 Bytes | |
932 | * index 0: port phy idx (e.g., 0,1,2,3), | |
933 | * index 1: It's could be | |
934 | * F81534_TOKEN_RECEIVE | |
935 | * F81534_TOKEN_TX_EMPTY | |
936 | * F81534_TOKEN_MSR_CHANGE | |
937 | * index 2: serial in size (data+lsr, must be even) | |
938 | * meaningful for F81534_TOKEN_RECEIVE only | |
939 | * index 3: current MSR with this device | |
940 | * index 4~127: serial in data block (data+lsr, must be even) | |
941 | */ | |
942 | switch (data[1]) { | |
943 | case F81534_TOKEN_TX_EMPTY: | |
944 | set_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty); | |
945 | ||
946 | /* Try to submit writer */ | |
947 | status = f81534_submit_writer(port, GFP_ATOMIC); | |
948 | if (status) | |
949 | dev_err(&port->dev, "%s: submit failed\n", __func__); | |
950 | return; | |
951 | ||
952 | case F81534_TOKEN_MSR_CHANGE: | |
953 | f81534_msr_changed(port, data[3]); | |
954 | return; | |
955 | ||
956 | case F81534_TOKEN_RECEIVE: | |
957 | read_size = data[2]; | |
958 | if (read_size > F81534_MAX_RX_SIZE) { | |
959 | dev_err(&port->dev, | |
960 | "%s: phy: %d read_size: %zu larger than: %d\n", | |
961 | __func__, phy_num, read_size, | |
962 | F81534_MAX_RX_SIZE); | |
963 | return; | |
964 | } | |
965 | ||
966 | break; | |
967 | ||
968 | default: | |
969 | dev_warn(&port->dev, "%s: unknown token: %02x\n", __func__, | |
970 | data[1]); | |
971 | return; | |
972 | } | |
973 | ||
974 | for (i = 4; i < 4 + read_size; i += 2) { | |
975 | tty_flag = TTY_NORMAL; | |
976 | lsr = data[i + 1]; | |
977 | ||
978 | if (lsr & UART_LSR_BRK_ERROR_BITS) { | |
979 | if (lsr & UART_LSR_BI) { | |
980 | tty_flag = TTY_BREAK; | |
981 | port->icount.brk++; | |
982 | usb_serial_handle_break(port); | |
983 | } else if (lsr & UART_LSR_PE) { | |
984 | tty_flag = TTY_PARITY; | |
985 | port->icount.parity++; | |
986 | } else if (lsr & UART_LSR_FE) { | |
987 | tty_flag = TTY_FRAME; | |
988 | port->icount.frame++; | |
989 | } | |
990 | ||
991 | if (lsr & UART_LSR_OE) { | |
992 | port->icount.overrun++; | |
993 | tty_insert_flip_char(&port->port, 0, | |
994 | TTY_OVERRUN); | |
995 | } | |
996 | } | |
997 | ||
998 | if (port->port.console && port->sysrq) { | |
999 | if (usb_serial_handle_sysrq_char(port, data[i])) | |
1000 | continue; | |
1001 | } | |
1002 | ||
1003 | tty_insert_flip_char(&port->port, data[i], tty_flag); | |
1004 | } | |
1005 | ||
1006 | tty_flip_buffer_push(&port->port); | |
1007 | } | |
1008 | ||
1009 | static void f81534_process_read_urb(struct urb *urb) | |
1010 | { | |
1011 | struct f81534_serial_private *serial_priv; | |
1012 | struct usb_serial_port *port; | |
1013 | struct usb_serial *serial; | |
1014 | u8 *buf; | |
1015 | int phy_port_num; | |
1016 | int tty_port_num; | |
1017 | size_t i; | |
1018 | ||
1019 | if (!urb->actual_length || | |
1020 | urb->actual_length % F81534_RECEIVE_BLOCK_SIZE) { | |
1021 | return; | |
1022 | } | |
1023 | ||
1024 | port = urb->context; | |
1025 | serial = port->serial; | |
1026 | buf = urb->transfer_buffer; | |
1027 | serial_priv = usb_get_serial_data(serial); | |
1028 | ||
1029 | for (i = 0; i < urb->actual_length; i += F81534_RECEIVE_BLOCK_SIZE) { | |
1030 | phy_port_num = buf[i]; | |
1031 | if (phy_port_num >= F81534_NUM_PORT) { | |
1032 | dev_err(&port->dev, | |
1033 | "%s: phy_port_num: %d larger than: %d\n", | |
1034 | __func__, phy_port_num, F81534_NUM_PORT); | |
1035 | continue; | |
1036 | } | |
1037 | ||
1038 | tty_port_num = serial_priv->tty_idx[phy_port_num]; | |
1039 | port = serial->port[tty_port_num]; | |
1040 | ||
1041 | if (tty_port_initialized(&port->port)) | |
1042 | f81534_process_per_serial_block(port, &buf[i]); | |
1043 | } | |
1044 | } | |
1045 | ||
1046 | static void f81534_write_usb_callback(struct urb *urb) | |
1047 | { | |
1048 | struct usb_serial_port *port = urb->context; | |
1049 | ||
1050 | switch (urb->status) { | |
1051 | case 0: | |
1052 | break; | |
1053 | case -ENOENT: | |
1054 | case -ECONNRESET: | |
1055 | case -ESHUTDOWN: | |
1056 | dev_dbg(&port->dev, "%s - urb stopped: %d\n", | |
1057 | __func__, urb->status); | |
1058 | return; | |
1059 | case -EPIPE: | |
1060 | dev_err(&port->dev, "%s - urb stopped: %d\n", | |
1061 | __func__, urb->status); | |
1062 | return; | |
1063 | default: | |
1064 | dev_dbg(&port->dev, "%s - nonzero urb status: %d\n", | |
1065 | __func__, urb->status); | |
1066 | break; | |
1067 | } | |
1068 | } | |
1069 | ||
1070 | static int f81534_setup_ports(struct usb_serial *serial) | |
1071 | { | |
1072 | struct usb_serial_port *port; | |
1073 | u8 port0_out_address; | |
1074 | int buffer_size; | |
1075 | size_t i; | |
1076 | ||
1077 | /* | |
1078 | * In our system architecture, we had 2 or 4 serial ports, | |
1079 | * but only get 1 set of bulk in/out endpoints. | |
1080 | * | |
1081 | * The usb-serial subsystem will generate port 0 data, | |
1082 | * but port 1/2/3 will not. It's will generate write URB and buffer | |
1083 | * by following code and use the port0 read URB for read operation. | |
1084 | */ | |
1085 | for (i = 1; i < serial->num_ports; ++i) { | |
1086 | port0_out_address = serial->port[0]->bulk_out_endpointAddress; | |
1087 | buffer_size = serial->port[0]->bulk_out_size; | |
1088 | port = serial->port[i]; | |
1089 | ||
1090 | if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL)) | |
1091 | return -ENOMEM; | |
1092 | ||
1093 | port->bulk_out_size = buffer_size; | |
1094 | port->bulk_out_endpointAddress = port0_out_address; | |
1095 | ||
1096 | port->write_urbs[0] = usb_alloc_urb(0, GFP_KERNEL); | |
1097 | if (!port->write_urbs[0]) | |
1098 | return -ENOMEM; | |
1099 | ||
1100 | port->bulk_out_buffers[0] = kzalloc(buffer_size, GFP_KERNEL); | |
1101 | if (!port->bulk_out_buffers[0]) | |
1102 | return -ENOMEM; | |
1103 | ||
1104 | usb_fill_bulk_urb(port->write_urbs[0], serial->dev, | |
1105 | usb_sndbulkpipe(serial->dev, | |
1106 | port0_out_address), | |
1107 | port->bulk_out_buffers[0], buffer_size, | |
1108 | serial->type->write_bulk_callback, port); | |
1109 | ||
1110 | port->write_urb = port->write_urbs[0]; | |
1111 | port->bulk_out_buffer = port->bulk_out_buffers[0]; | |
1112 | } | |
1113 | ||
1114 | return 0; | |
1115 | } | |
1116 | ||
1117 | static int f81534_probe(struct usb_serial *serial, | |
1118 | const struct usb_device_id *id) | |
1119 | { | |
1120 | struct usb_endpoint_descriptor *endpoint; | |
1121 | struct usb_host_interface *iface_desc; | |
1122 | struct device *dev; | |
1123 | int num_bulk_in = 0; | |
1124 | int num_bulk_out = 0; | |
1125 | int size_bulk_in = 0; | |
1126 | int size_bulk_out = 0; | |
1127 | int i; | |
1128 | ||
1129 | dev = &serial->interface->dev; | |
1130 | iface_desc = serial->interface->cur_altsetting; | |
1131 | ||
1132 | for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { | |
1133 | endpoint = &iface_desc->endpoint[i].desc; | |
1134 | ||
1135 | if (usb_endpoint_is_bulk_in(endpoint)) { | |
1136 | ++num_bulk_in; | |
1137 | size_bulk_in = usb_endpoint_maxp(endpoint); | |
1138 | } | |
1139 | ||
1140 | if (usb_endpoint_is_bulk_out(endpoint)) { | |
1141 | ++num_bulk_out; | |
1142 | size_bulk_out = usb_endpoint_maxp(endpoint); | |
1143 | } | |
1144 | } | |
1145 | ||
1146 | if (num_bulk_in != 1 || num_bulk_out != 1) { | |
1147 | dev_err(dev, "expected endpoints not found\n"); | |
1148 | return -ENODEV; | |
1149 | } | |
1150 | ||
1151 | if (size_bulk_out != F81534_WRITE_BUFFER_SIZE || | |
1152 | size_bulk_in != F81534_MAX_RECEIVE_BLOCK_SIZE) { | |
1153 | dev_err(dev, "unsupported endpoint max packet size\n"); | |
1154 | return -ENODEV; | |
1155 | } | |
1156 | ||
1157 | return 0; | |
1158 | } | |
1159 | ||
1160 | static int f81534_attach(struct usb_serial *serial) | |
1161 | { | |
1162 | struct f81534_serial_private *serial_priv; | |
1163 | int index = 0; | |
1164 | int status; | |
1165 | int i; | |
1166 | ||
1167 | serial_priv = devm_kzalloc(&serial->interface->dev, | |
1168 | sizeof(*serial_priv), GFP_KERNEL); | |
1169 | if (!serial_priv) | |
1170 | return -ENOMEM; | |
1171 | ||
1172 | usb_set_serial_data(serial, serial_priv); | |
1173 | ||
1174 | mutex_init(&serial_priv->urb_mutex); | |
1175 | ||
1176 | status = f81534_setup_ports(serial); | |
1177 | if (status) | |
1178 | return status; | |
1179 | ||
1180 | /* Check had custom setting */ | |
1181 | status = f81534_find_config_idx(serial, &serial_priv->setting_idx); | |
1182 | if (status) { | |
1183 | dev_err(&serial->interface->dev, "%s: find idx failed: %d\n", | |
1184 | __func__, status); | |
1185 | return status; | |
1186 | } | |
1187 | ||
1188 | /* | |
1189 | * We'll read custom data only when data available, otherwise we'll | |
1190 | * read default value instead. | |
1191 | */ | |
1192 | if (serial_priv->setting_idx == F81534_CUSTOM_NO_CUSTOM_DATA) { | |
1193 | /* | |
1194 | * The default configuration layout: | |
1195 | * byte 0/1/2/3: uart setting | |
1196 | */ | |
1197 | status = f81534_read_flash(serial, | |
1198 | F81534_DEF_CONF_ADDRESS_START, | |
1199 | F81534_DEF_CONF_SIZE, | |
1200 | serial_priv->conf_data); | |
1201 | if (status) { | |
1202 | dev_err(&serial->interface->dev, | |
1203 | "%s: read reserve data failed: %d\n", | |
1204 | __func__, status); | |
1205 | return status; | |
1206 | } | |
1207 | } else { | |
1208 | /* Only read 8 bytes for mode & GPIO */ | |
1209 | status = f81534_read_flash(serial, | |
1210 | F81534_CUSTOM_ADDRESS_START + | |
1211 | F81534_CONF_OFFSET, | |
1212 | sizeof(serial_priv->conf_data), | |
1213 | serial_priv->conf_data); | |
1214 | if (status) { | |
1215 | dev_err(&serial->interface->dev, | |
1216 | "%s: idx: %d get data failed: %d\n", | |
1217 | __func__, serial_priv->setting_idx, | |
1218 | status); | |
1219 | return status; | |
1220 | } | |
1221 | } | |
1222 | ||
1223 | /* Assign phy-to-logic mapping */ | |
1224 | for (i = 0; i < F81534_NUM_PORT; ++i) { | |
1225 | if (serial_priv->conf_data[i] & F81534_PORT_UNAVAILABLE) | |
1226 | continue; | |
1227 | ||
1228 | serial_priv->tty_idx[i] = index++; | |
1229 | dev_dbg(&serial->interface->dev, | |
1230 | "%s: phy_num: %d, tty_idx: %d\n", __func__, i, | |
1231 | serial_priv->tty_idx[i]); | |
1232 | } | |
1233 | ||
1234 | return 0; | |
1235 | } | |
1236 | ||
1237 | static int f81534_port_probe(struct usb_serial_port *port) | |
1238 | { | |
1239 | struct f81534_port_private *port_priv; | |
42715763 | 1240 | int ret; |
0c9bd600 JZHPH |
1241 | |
1242 | port_priv = devm_kzalloc(&port->dev, sizeof(*port_priv), GFP_KERNEL); | |
1243 | if (!port_priv) | |
1244 | return -ENOMEM; | |
1245 | ||
1246 | spin_lock_init(&port_priv->msr_lock); | |
1247 | mutex_init(&port_priv->mcr_mutex); | |
1248 | ||
1249 | /* Assign logic-to-phy mapping */ | |
42715763 GU |
1250 | ret = f81534_logic_to_phy_port(port->serial, port); |
1251 | if (ret < 0) | |
1252 | return ret; | |
0c9bd600 | 1253 | |
42715763 | 1254 | port_priv->phy_num = ret; |
0c9bd600 JZHPH |
1255 | usb_set_serial_port_data(port, port_priv); |
1256 | dev_dbg(&port->dev, "%s: port_number: %d, phy_num: %d\n", __func__, | |
1257 | port->port_number, port_priv->phy_num); | |
1258 | ||
1259 | return 0; | |
1260 | } | |
1261 | ||
1262 | static int f81534_tiocmget(struct tty_struct *tty) | |
1263 | { | |
1264 | struct usb_serial_port *port = tty->driver_data; | |
1265 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
1266 | int status; | |
1267 | int r; | |
1268 | u8 msr; | |
1269 | u8 mcr; | |
1270 | ||
1271 | /* Read current MSR from device */ | |
1272 | status = f81534_get_port_register(port, F81534_MODEM_STATUS_REG, &msr); | |
1273 | if (status) | |
1274 | return status; | |
1275 | ||
1276 | mutex_lock(&port_priv->mcr_mutex); | |
1277 | mcr = port_priv->shadow_mcr; | |
1278 | mutex_unlock(&port_priv->mcr_mutex); | |
1279 | ||
1280 | r = (mcr & UART_MCR_DTR ? TIOCM_DTR : 0) | | |
1281 | (mcr & UART_MCR_RTS ? TIOCM_RTS : 0) | | |
1282 | (msr & UART_MSR_CTS ? TIOCM_CTS : 0) | | |
1283 | (msr & UART_MSR_DCD ? TIOCM_CAR : 0) | | |
1284 | (msr & UART_MSR_RI ? TIOCM_RI : 0) | | |
1285 | (msr & UART_MSR_DSR ? TIOCM_DSR : 0); | |
1286 | ||
1287 | return r; | |
1288 | } | |
1289 | ||
1290 | static int f81534_tiocmset(struct tty_struct *tty, unsigned int set, | |
1291 | unsigned int clear) | |
1292 | { | |
1293 | struct usb_serial_port *port = tty->driver_data; | |
1294 | ||
1295 | return f81534_update_mctrl(port, set, clear); | |
1296 | } | |
1297 | ||
1298 | static void f81534_dtr_rts(struct usb_serial_port *port, int on) | |
1299 | { | |
1300 | if (on) | |
1301 | f81534_update_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0); | |
1302 | else | |
1303 | f81534_update_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS); | |
1304 | } | |
1305 | ||
1306 | static int f81534_write(struct tty_struct *tty, struct usb_serial_port *port, | |
1307 | const u8 *buf, int count) | |
1308 | { | |
1309 | int bytes_out, status; | |
1310 | ||
1311 | if (!count) | |
1312 | return 0; | |
1313 | ||
1314 | bytes_out = kfifo_in_locked(&port->write_fifo, buf, count, | |
1315 | &port->lock); | |
1316 | ||
1317 | status = f81534_submit_writer(port, GFP_ATOMIC); | |
1318 | if (status) { | |
1319 | dev_err(&port->dev, "%s: submit failed\n", __func__); | |
1320 | return status; | |
1321 | } | |
1322 | ||
1323 | return bytes_out; | |
1324 | } | |
1325 | ||
1326 | static bool f81534_tx_empty(struct usb_serial_port *port) | |
1327 | { | |
1328 | struct f81534_port_private *port_priv = usb_get_serial_port_data(port); | |
1329 | ||
1330 | return test_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty); | |
1331 | } | |
1332 | ||
1333 | static int f81534_resume(struct usb_serial *serial) | |
1334 | { | |
1335 | struct f81534_serial_private *serial_priv = | |
1336 | usb_get_serial_data(serial); | |
1337 | struct usb_serial_port *port; | |
1338 | int error = 0; | |
1339 | int status; | |
1340 | size_t i; | |
1341 | ||
1342 | /* | |
1343 | * We'll register port 0 bulkin when port had opened, It'll take all | |
1344 | * port received data, MSR register change and TX_EMPTY information. | |
1345 | */ | |
1346 | mutex_lock(&serial_priv->urb_mutex); | |
1347 | ||
1348 | if (serial_priv->opened_port) { | |
1349 | status = f81534_submit_read_urb(serial, GFP_NOIO); | |
1350 | if (status) { | |
1351 | mutex_unlock(&serial_priv->urb_mutex); | |
1352 | return status; | |
1353 | } | |
1354 | } | |
1355 | ||
1356 | mutex_unlock(&serial_priv->urb_mutex); | |
1357 | ||
1358 | for (i = 0; i < serial->num_ports; i++) { | |
1359 | port = serial->port[i]; | |
1360 | if (!tty_port_initialized(&port->port)) | |
1361 | continue; | |
1362 | ||
1363 | status = f81534_submit_writer(port, GFP_NOIO); | |
1364 | if (status) { | |
1365 | dev_err(&port->dev, "%s: submit failed\n", __func__); | |
1366 | ++error; | |
1367 | } | |
1368 | } | |
1369 | ||
1370 | if (error) | |
1371 | return -EIO; | |
1372 | ||
1373 | return 0; | |
1374 | } | |
1375 | ||
1376 | static struct usb_serial_driver f81534_device = { | |
1377 | .driver = { | |
1378 | .owner = THIS_MODULE, | |
1379 | .name = "f81534", | |
1380 | }, | |
1381 | .description = DRIVER_DESC, | |
1382 | .id_table = f81534_id_table, | |
1383 | .open = f81534_open, | |
1384 | .close = f81534_close, | |
1385 | .write = f81534_write, | |
1386 | .tx_empty = f81534_tx_empty, | |
1387 | .calc_num_ports = f81534_calc_num_ports, | |
1388 | .probe = f81534_probe, | |
1389 | .attach = f81534_attach, | |
1390 | .port_probe = f81534_port_probe, | |
1391 | .dtr_rts = f81534_dtr_rts, | |
1392 | .process_read_urb = f81534_process_read_urb, | |
1393 | .ioctl = f81534_ioctl, | |
1394 | .tiocmget = f81534_tiocmget, | |
1395 | .tiocmset = f81534_tiocmset, | |
1396 | .write_bulk_callback = f81534_write_usb_callback, | |
1397 | .set_termios = f81534_set_termios, | |
1398 | .resume = f81534_resume, | |
1399 | }; | |
1400 | ||
1401 | static struct usb_serial_driver *const serial_drivers[] = { | |
1402 | &f81534_device, NULL | |
1403 | }; | |
1404 | ||
1405 | module_usb_serial_driver(serial_drivers, f81534_id_table); | |
1406 | ||
1407 | MODULE_DEVICE_TABLE(usb, f81534_id_table); | |
1408 | MODULE_DESCRIPTION(DRIVER_DESC); | |
1409 | MODULE_AUTHOR("Peter Hong <Peter_Hong@fintek.com.tw>"); | |
1410 | MODULE_AUTHOR("Tom Tsai <Tom_Tsai@fintek.com.tw>"); | |
1411 | MODULE_LICENSE("GPL"); |