Root/
1 | /* |
2 | * |
3 | * Copyright (C) 2008 Christian Pellegrin <chripell@evolware.org> |
4 | * |
5 | * This program is free software; you can redistribute it and/or modify |
6 | * it under the terms of the GNU General Public License as published by |
7 | * the Free Software Foundation; either version 2 of the License, or |
8 | * (at your option) any later version. |
9 | * |
10 | * |
11 | * Notes: the MAX3100 doesn't provide an interrupt on CTS so we have |
12 | * to use polling for flow control. TX empty IRQ is unusable, since |
13 | * writing conf clears FIFO buffer and we cannot have this interrupt |
14 | * always asking us for attention. |
15 | * |
16 | * Example platform data: |
17 | |
18 | static struct plat_max3100 max3100_plat_data = { |
19 | .loopback = 0, |
20 | .crystal = 0, |
21 | .poll_time = 100, |
22 | }; |
23 | |
24 | static struct spi_board_info spi_board_info[] = { |
25 | { |
26 | .modalias = "max3100", |
27 | .platform_data = &max3100_plat_data, |
28 | .irq = IRQ_EINT12, |
29 | .max_speed_hz = 5*1000*1000, |
30 | .chip_select = 0, |
31 | }, |
32 | }; |
33 | |
34 | * The initial minor number is 209 in the low-density serial port: |
35 | * mknod /dev/ttyMAX0 c 204 209 |
36 | */ |
37 | |
38 | #define MAX3100_MAJOR 204 |
39 | #define MAX3100_MINOR 209 |
40 | /* 4 MAX3100s should be enough for everyone */ |
41 | #define MAX_MAX3100 4 |
42 | |
43 | #include <linux/delay.h> |
44 | #include <linux/slab.h> |
45 | #include <linux/device.h> |
46 | #include <linux/module.h> |
47 | #include <linux/serial_core.h> |
48 | #include <linux/serial.h> |
49 | #include <linux/spi/spi.h> |
50 | #include <linux/freezer.h> |
51 | #include <linux/tty.h> |
52 | #include <linux/tty_flip.h> |
53 | |
54 | #include <linux/serial_max3100.h> |
55 | |
56 | #define MAX3100_C (1<<14) |
57 | #define MAX3100_D (0<<14) |
58 | #define MAX3100_W (1<<15) |
59 | #define MAX3100_RX (0<<15) |
60 | |
61 | #define MAX3100_WC (MAX3100_W | MAX3100_C) |
62 | #define MAX3100_RC (MAX3100_RX | MAX3100_C) |
63 | #define MAX3100_WD (MAX3100_W | MAX3100_D) |
64 | #define MAX3100_RD (MAX3100_RX | MAX3100_D) |
65 | #define MAX3100_CMD (3 << 14) |
66 | |
67 | #define MAX3100_T (1<<14) |
68 | #define MAX3100_R (1<<15) |
69 | |
70 | #define MAX3100_FEN (1<<13) |
71 | #define MAX3100_SHDN (1<<12) |
72 | #define MAX3100_TM (1<<11) |
73 | #define MAX3100_RM (1<<10) |
74 | #define MAX3100_PM (1<<9) |
75 | #define MAX3100_RAM (1<<8) |
76 | #define MAX3100_IR (1<<7) |
77 | #define MAX3100_ST (1<<6) |
78 | #define MAX3100_PE (1<<5) |
79 | #define MAX3100_L (1<<4) |
80 | #define MAX3100_BAUD (0xf) |
81 | |
82 | #define MAX3100_TE (1<<10) |
83 | #define MAX3100_RAFE (1<<10) |
84 | #define MAX3100_RTS (1<<9) |
85 | #define MAX3100_CTS (1<<9) |
86 | #define MAX3100_PT (1<<8) |
87 | #define MAX3100_DATA (0xff) |
88 | |
89 | #define MAX3100_RT (MAX3100_R | MAX3100_T) |
90 | #define MAX3100_RTC (MAX3100_RT | MAX3100_CTS | MAX3100_RAFE) |
91 | |
92 | /* the following simulate a status reg for ignore_status_mask */ |
93 | #define MAX3100_STATUS_PE 1 |
94 | #define MAX3100_STATUS_FE 2 |
95 | #define MAX3100_STATUS_OE 4 |
96 | |
97 | struct max3100_port { |
98 | struct uart_port port; |
99 | struct spi_device *spi; |
100 | |
101 | int cts; /* last CTS received for flow ctrl */ |
102 | int tx_empty; /* last TX empty bit */ |
103 | |
104 | spinlock_t conf_lock; /* shared data */ |
105 | int conf_commit; /* need to make changes */ |
106 | int conf; /* configuration for the MAX31000 |
107 | * (bits 0-7, bits 8-11 are irqs) */ |
108 | int rts_commit; /* need to change rts */ |
109 | int rts; /* rts status */ |
110 | int baud; /* current baud rate */ |
111 | |
112 | int parity; /* keeps track if we should send parity */ |
113 | #define MAX3100_PARITY_ON 1 |
114 | #define MAX3100_PARITY_ODD 2 |
115 | #define MAX3100_7BIT 4 |
116 | int rx_enabled; /* if we should rx chars */ |
117 | |
118 | int irq; /* irq assigned to the max3100 */ |
119 | |
120 | int minor; /* minor number */ |
121 | int crystal; /* 1 if 3.6864Mhz crystal 0 for 1.8432 */ |
122 | int loopback; /* 1 if we are in loopback mode */ |
123 | |
124 | /* for handling irqs: need workqueue since we do spi_sync */ |
125 | struct workqueue_struct *workqueue; |
126 | struct work_struct work; |
127 | /* set to 1 to make the workhandler exit as soon as possible */ |
128 | int force_end_work; |
129 | /* need to know we are suspending to avoid deadlock on workqueue */ |
130 | int suspending; |
131 | |
132 | /* hook for suspending MAX3100 via dedicated pin */ |
133 | void (*max3100_hw_suspend) (int suspend); |
134 | |
135 | /* poll time (in ms) for ctrl lines */ |
136 | int poll_time; |
137 | /* and its timer */ |
138 | struct timer_list timer; |
139 | }; |
140 | |
141 | static struct max3100_port *max3100s[MAX_MAX3100]; /* the chips */ |
142 | static DEFINE_MUTEX(max3100s_lock); /* race on probe */ |
143 | |
144 | static int max3100_do_parity(struct max3100_port *s, u16 c) |
145 | { |
146 | int parity; |
147 | |
148 | if (s->parity & MAX3100_PARITY_ODD) |
149 | parity = 1; |
150 | else |
151 | parity = 0; |
152 | |
153 | if (s->parity & MAX3100_7BIT) |
154 | c &= 0x7f; |
155 | else |
156 | c &= 0xff; |
157 | |
158 | parity = parity ^ (hweight8(c) & 1); |
159 | return parity; |
160 | } |
161 | |
162 | static int max3100_check_parity(struct max3100_port *s, u16 c) |
163 | { |
164 | return max3100_do_parity(s, c) == ((c >> 8) & 1); |
165 | } |
166 | |
167 | static void max3100_calc_parity(struct max3100_port *s, u16 *c) |
168 | { |
169 | if (s->parity & MAX3100_7BIT) |
170 | *c &= 0x7f; |
171 | else |
172 | *c &= 0xff; |
173 | |
174 | if (s->parity & MAX3100_PARITY_ON) |
175 | *c |= max3100_do_parity(s, *c) << 8; |
176 | } |
177 | |
178 | static void max3100_work(struct work_struct *w); |
179 | |
180 | static void max3100_dowork(struct max3100_port *s) |
181 | { |
182 | if (!s->force_end_work && !freezing(current) && !s->suspending) |
183 | queue_work(s->workqueue, &s->work); |
184 | } |
185 | |
186 | static void max3100_timeout(unsigned long data) |
187 | { |
188 | struct max3100_port *s = (struct max3100_port *)data; |
189 | |
190 | if (s->port.state) { |
191 | max3100_dowork(s); |
192 | mod_timer(&s->timer, jiffies + s->poll_time); |
193 | } |
194 | } |
195 | |
196 | static int max3100_sr(struct max3100_port *s, u16 tx, u16 *rx) |
197 | { |
198 | struct spi_message message; |
199 | u16 etx, erx; |
200 | int status; |
201 | struct spi_transfer tran = { |
202 | .tx_buf = &etx, |
203 | .rx_buf = &erx, |
204 | .len = 2, |
205 | }; |
206 | |
207 | etx = cpu_to_be16(tx); |
208 | spi_message_init(&message); |
209 | spi_message_add_tail(&tran, &message); |
210 | status = spi_sync(s->spi, &message); |
211 | if (status) { |
212 | dev_warn(&s->spi->dev, "error while calling spi_sync\n"); |
213 | return -EIO; |
214 | } |
215 | *rx = be16_to_cpu(erx); |
216 | s->tx_empty = (*rx & MAX3100_T) > 0; |
217 | dev_dbg(&s->spi->dev, "%04x - %04x\n", tx, *rx); |
218 | return 0; |
219 | } |
220 | |
221 | static int max3100_handlerx(struct max3100_port *s, u16 rx) |
222 | { |
223 | unsigned int ch, flg, status = 0; |
224 | int ret = 0, cts; |
225 | |
226 | if (rx & MAX3100_R && s->rx_enabled) { |
227 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
228 | ch = rx & (s->parity & MAX3100_7BIT ? 0x7f : 0xff); |
229 | if (rx & MAX3100_RAFE) { |
230 | s->port.icount.frame++; |
231 | flg = TTY_FRAME; |
232 | status |= MAX3100_STATUS_FE; |
233 | } else { |
234 | if (s->parity & MAX3100_PARITY_ON) { |
235 | if (max3100_check_parity(s, rx)) { |
236 | s->port.icount.rx++; |
237 | flg = TTY_NORMAL; |
238 | } else { |
239 | s->port.icount.parity++; |
240 | flg = TTY_PARITY; |
241 | status |= MAX3100_STATUS_PE; |
242 | } |
243 | } else { |
244 | s->port.icount.rx++; |
245 | flg = TTY_NORMAL; |
246 | } |
247 | } |
248 | uart_insert_char(&s->port, status, MAX3100_STATUS_OE, ch, flg); |
249 | ret = 1; |
250 | } |
251 | |
252 | cts = (rx & MAX3100_CTS) > 0; |
253 | if (s->cts != cts) { |
254 | s->cts = cts; |
255 | uart_handle_cts_change(&s->port, cts ? TIOCM_CTS : 0); |
256 | } |
257 | |
258 | return ret; |
259 | } |
260 | |
261 | static void max3100_work(struct work_struct *w) |
262 | { |
263 | struct max3100_port *s = container_of(w, struct max3100_port, work); |
264 | int rxchars; |
265 | u16 tx, rx; |
266 | int conf, cconf, rts, crts; |
267 | struct circ_buf *xmit = &s->port.state->xmit; |
268 | |
269 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
270 | |
271 | rxchars = 0; |
272 | do { |
273 | spin_lock(&s->conf_lock); |
274 | conf = s->conf; |
275 | cconf = s->conf_commit; |
276 | s->conf_commit = 0; |
277 | rts = s->rts; |
278 | crts = s->rts_commit; |
279 | s->rts_commit = 0; |
280 | spin_unlock(&s->conf_lock); |
281 | if (cconf) |
282 | max3100_sr(s, MAX3100_WC | conf, &rx); |
283 | if (crts) { |
284 | max3100_sr(s, MAX3100_WD | MAX3100_TE | |
285 | (s->rts ? MAX3100_RTS : 0), &rx); |
286 | rxchars += max3100_handlerx(s, rx); |
287 | } |
288 | |
289 | max3100_sr(s, MAX3100_RD, &rx); |
290 | rxchars += max3100_handlerx(s, rx); |
291 | |
292 | if (rx & MAX3100_T) { |
293 | tx = 0xffff; |
294 | if (s->port.x_char) { |
295 | tx = s->port.x_char; |
296 | s->port.icount.tx++; |
297 | s->port.x_char = 0; |
298 | } else if (!uart_circ_empty(xmit) && |
299 | !uart_tx_stopped(&s->port)) { |
300 | tx = xmit->buf[xmit->tail]; |
301 | xmit->tail = (xmit->tail + 1) & |
302 | (UART_XMIT_SIZE - 1); |
303 | s->port.icount.tx++; |
304 | } |
305 | if (tx != 0xffff) { |
306 | max3100_calc_parity(s, &tx); |
307 | tx |= MAX3100_WD | (s->rts ? MAX3100_RTS : 0); |
308 | max3100_sr(s, tx, &rx); |
309 | rxchars += max3100_handlerx(s, rx); |
310 | } |
311 | } |
312 | |
313 | if (rxchars > 16) { |
314 | tty_flip_buffer_push(&s->port.state->port); |
315 | rxchars = 0; |
316 | } |
317 | if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) |
318 | uart_write_wakeup(&s->port); |
319 | |
320 | } while (!s->force_end_work && |
321 | !freezing(current) && |
322 | ((rx & MAX3100_R) || |
323 | (!uart_circ_empty(xmit) && |
324 | !uart_tx_stopped(&s->port)))); |
325 | |
326 | if (rxchars > 0) |
327 | tty_flip_buffer_push(&s->port.state->port); |
328 | } |
329 | |
330 | static irqreturn_t max3100_irq(int irqno, void *dev_id) |
331 | { |
332 | struct max3100_port *s = dev_id; |
333 | |
334 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
335 | |
336 | max3100_dowork(s); |
337 | return IRQ_HANDLED; |
338 | } |
339 | |
340 | static void max3100_enable_ms(struct uart_port *port) |
341 | { |
342 | struct max3100_port *s = container_of(port, |
343 | struct max3100_port, |
344 | port); |
345 | |
346 | if (s->poll_time > 0) |
347 | mod_timer(&s->timer, jiffies); |
348 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
349 | } |
350 | |
351 | static void max3100_start_tx(struct uart_port *port) |
352 | { |
353 | struct max3100_port *s = container_of(port, |
354 | struct max3100_port, |
355 | port); |
356 | |
357 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
358 | |
359 | max3100_dowork(s); |
360 | } |
361 | |
362 | static void max3100_stop_rx(struct uart_port *port) |
363 | { |
364 | struct max3100_port *s = container_of(port, |
365 | struct max3100_port, |
366 | port); |
367 | |
368 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
369 | |
370 | s->rx_enabled = 0; |
371 | spin_lock(&s->conf_lock); |
372 | s->conf &= ~MAX3100_RM; |
373 | s->conf_commit = 1; |
374 | spin_unlock(&s->conf_lock); |
375 | max3100_dowork(s); |
376 | } |
377 | |
378 | static unsigned int max3100_tx_empty(struct uart_port *port) |
379 | { |
380 | struct max3100_port *s = container_of(port, |
381 | struct max3100_port, |
382 | port); |
383 | |
384 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
385 | |
386 | /* may not be truly up-to-date */ |
387 | max3100_dowork(s); |
388 | return s->tx_empty; |
389 | } |
390 | |
391 | static unsigned int max3100_get_mctrl(struct uart_port *port) |
392 | { |
393 | struct max3100_port *s = container_of(port, |
394 | struct max3100_port, |
395 | port); |
396 | |
397 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
398 | |
399 | /* may not be truly up-to-date */ |
400 | max3100_dowork(s); |
401 | /* always assert DCD and DSR since these lines are not wired */ |
402 | return (s->cts ? TIOCM_CTS : 0) | TIOCM_DSR | TIOCM_CAR; |
403 | } |
404 | |
405 | static void max3100_set_mctrl(struct uart_port *port, unsigned int mctrl) |
406 | { |
407 | struct max3100_port *s = container_of(port, |
408 | struct max3100_port, |
409 | port); |
410 | int rts; |
411 | |
412 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
413 | |
414 | rts = (mctrl & TIOCM_RTS) > 0; |
415 | |
416 | spin_lock(&s->conf_lock); |
417 | if (s->rts != rts) { |
418 | s->rts = rts; |
419 | s->rts_commit = 1; |
420 | max3100_dowork(s); |
421 | } |
422 | spin_unlock(&s->conf_lock); |
423 | } |
424 | |
425 | static void |
426 | max3100_set_termios(struct uart_port *port, struct ktermios *termios, |
427 | struct ktermios *old) |
428 | { |
429 | struct max3100_port *s = container_of(port, |
430 | struct max3100_port, |
431 | port); |
432 | int baud = 0; |
433 | unsigned cflag; |
434 | u32 param_new, param_mask, parity = 0; |
435 | |
436 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
437 | |
438 | cflag = termios->c_cflag; |
439 | param_new = 0; |
440 | param_mask = 0; |
441 | |
442 | baud = tty_termios_baud_rate(termios); |
443 | param_new = s->conf & MAX3100_BAUD; |
444 | switch (baud) { |
445 | case 300: |
446 | if (s->crystal) |
447 | baud = s->baud; |
448 | else |
449 | param_new = 15; |
450 | break; |
451 | case 600: |
452 | param_new = 14 + s->crystal; |
453 | break; |
454 | case 1200: |
455 | param_new = 13 + s->crystal; |
456 | break; |
457 | case 2400: |
458 | param_new = 12 + s->crystal; |
459 | break; |
460 | case 4800: |
461 | param_new = 11 + s->crystal; |
462 | break; |
463 | case 9600: |
464 | param_new = 10 + s->crystal; |
465 | break; |
466 | case 19200: |
467 | param_new = 9 + s->crystal; |
468 | break; |
469 | case 38400: |
470 | param_new = 8 + s->crystal; |
471 | break; |
472 | case 57600: |
473 | param_new = 1 + s->crystal; |
474 | break; |
475 | case 115200: |
476 | param_new = 0 + s->crystal; |
477 | break; |
478 | case 230400: |
479 | if (s->crystal) |
480 | param_new = 0; |
481 | else |
482 | baud = s->baud; |
483 | break; |
484 | default: |
485 | baud = s->baud; |
486 | } |
487 | tty_termios_encode_baud_rate(termios, baud, baud); |
488 | s->baud = baud; |
489 | param_mask |= MAX3100_BAUD; |
490 | |
491 | if ((cflag & CSIZE) == CS8) { |
492 | param_new &= ~MAX3100_L; |
493 | parity &= ~MAX3100_7BIT; |
494 | } else { |
495 | param_new |= MAX3100_L; |
496 | parity |= MAX3100_7BIT; |
497 | cflag = (cflag & ~CSIZE) | CS7; |
498 | } |
499 | param_mask |= MAX3100_L; |
500 | |
501 | if (cflag & CSTOPB) |
502 | param_new |= MAX3100_ST; |
503 | else |
504 | param_new &= ~MAX3100_ST; |
505 | param_mask |= MAX3100_ST; |
506 | |
507 | if (cflag & PARENB) { |
508 | param_new |= MAX3100_PE; |
509 | parity |= MAX3100_PARITY_ON; |
510 | } else { |
511 | param_new &= ~MAX3100_PE; |
512 | parity &= ~MAX3100_PARITY_ON; |
513 | } |
514 | param_mask |= MAX3100_PE; |
515 | |
516 | if (cflag & PARODD) |
517 | parity |= MAX3100_PARITY_ODD; |
518 | else |
519 | parity &= ~MAX3100_PARITY_ODD; |
520 | |
521 | /* mask termios capabilities we don't support */ |
522 | cflag &= ~CMSPAR; |
523 | termios->c_cflag = cflag; |
524 | |
525 | s->port.ignore_status_mask = 0; |
526 | if (termios->c_iflag & IGNPAR) |
527 | s->port.ignore_status_mask |= |
528 | MAX3100_STATUS_PE | MAX3100_STATUS_FE | |
529 | MAX3100_STATUS_OE; |
530 | |
531 | /* we are sending char from a workqueue so enable */ |
532 | s->port.state->port.low_latency = 1; |
533 | |
534 | if (s->poll_time > 0) |
535 | del_timer_sync(&s->timer); |
536 | |
537 | uart_update_timeout(port, termios->c_cflag, baud); |
538 | |
539 | spin_lock(&s->conf_lock); |
540 | s->conf = (s->conf & ~param_mask) | (param_new & param_mask); |
541 | s->conf_commit = 1; |
542 | s->parity = parity; |
543 | spin_unlock(&s->conf_lock); |
544 | max3100_dowork(s); |
545 | |
546 | if (UART_ENABLE_MS(&s->port, termios->c_cflag)) |
547 | max3100_enable_ms(&s->port); |
548 | } |
549 | |
550 | static void max3100_shutdown(struct uart_port *port) |
551 | { |
552 | struct max3100_port *s = container_of(port, |
553 | struct max3100_port, |
554 | port); |
555 | |
556 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
557 | |
558 | if (s->suspending) |
559 | return; |
560 | |
561 | s->force_end_work = 1; |
562 | |
563 | if (s->poll_time > 0) |
564 | del_timer_sync(&s->timer); |
565 | |
566 | if (s->workqueue) { |
567 | flush_workqueue(s->workqueue); |
568 | destroy_workqueue(s->workqueue); |
569 | s->workqueue = NULL; |
570 | } |
571 | if (s->irq) |
572 | free_irq(s->irq, s); |
573 | |
574 | /* set shutdown mode to save power */ |
575 | if (s->max3100_hw_suspend) |
576 | s->max3100_hw_suspend(1); |
577 | else { |
578 | u16 tx, rx; |
579 | |
580 | tx = MAX3100_WC | MAX3100_SHDN; |
581 | max3100_sr(s, tx, &rx); |
582 | } |
583 | } |
584 | |
585 | static int max3100_startup(struct uart_port *port) |
586 | { |
587 | struct max3100_port *s = container_of(port, |
588 | struct max3100_port, |
589 | port); |
590 | char b[12]; |
591 | |
592 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
593 | |
594 | s->conf = MAX3100_RM; |
595 | s->baud = s->crystal ? 230400 : 115200; |
596 | s->rx_enabled = 1; |
597 | |
598 | if (s->suspending) |
599 | return 0; |
600 | |
601 | s->force_end_work = 0; |
602 | s->parity = 0; |
603 | s->rts = 0; |
604 | |
605 | sprintf(b, "max3100-%d", s->minor); |
606 | s->workqueue = create_freezable_workqueue(b); |
607 | if (!s->workqueue) { |
608 | dev_warn(&s->spi->dev, "cannot create workqueue\n"); |
609 | return -EBUSY; |
610 | } |
611 | INIT_WORK(&s->work, max3100_work); |
612 | |
613 | if (request_irq(s->irq, max3100_irq, |
614 | IRQF_TRIGGER_FALLING, "max3100", s) < 0) { |
615 | dev_warn(&s->spi->dev, "cannot allocate irq %d\n", s->irq); |
616 | s->irq = 0; |
617 | destroy_workqueue(s->workqueue); |
618 | s->workqueue = NULL; |
619 | return -EBUSY; |
620 | } |
621 | |
622 | if (s->loopback) { |
623 | u16 tx, rx; |
624 | tx = 0x4001; |
625 | max3100_sr(s, tx, &rx); |
626 | } |
627 | |
628 | if (s->max3100_hw_suspend) |
629 | s->max3100_hw_suspend(0); |
630 | s->conf_commit = 1; |
631 | max3100_dowork(s); |
632 | /* wait for clock to settle */ |
633 | msleep(50); |
634 | |
635 | max3100_enable_ms(&s->port); |
636 | |
637 | return 0; |
638 | } |
639 | |
640 | static const char *max3100_type(struct uart_port *port) |
641 | { |
642 | struct max3100_port *s = container_of(port, |
643 | struct max3100_port, |
644 | port); |
645 | |
646 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
647 | |
648 | return s->port.type == PORT_MAX3100 ? "MAX3100" : NULL; |
649 | } |
650 | |
651 | static void max3100_release_port(struct uart_port *port) |
652 | { |
653 | struct max3100_port *s = container_of(port, |
654 | struct max3100_port, |
655 | port); |
656 | |
657 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
658 | } |
659 | |
660 | static void max3100_config_port(struct uart_port *port, int flags) |
661 | { |
662 | struct max3100_port *s = container_of(port, |
663 | struct max3100_port, |
664 | port); |
665 | |
666 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
667 | |
668 | if (flags & UART_CONFIG_TYPE) |
669 | s->port.type = PORT_MAX3100; |
670 | } |
671 | |
672 | static int max3100_verify_port(struct uart_port *port, |
673 | struct serial_struct *ser) |
674 | { |
675 | struct max3100_port *s = container_of(port, |
676 | struct max3100_port, |
677 | port); |
678 | int ret = -EINVAL; |
679 | |
680 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
681 | |
682 | if (ser->type == PORT_UNKNOWN || ser->type == PORT_MAX3100) |
683 | ret = 0; |
684 | return ret; |
685 | } |
686 | |
687 | static void max3100_stop_tx(struct uart_port *port) |
688 | { |
689 | struct max3100_port *s = container_of(port, |
690 | struct max3100_port, |
691 | port); |
692 | |
693 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
694 | } |
695 | |
696 | static int max3100_request_port(struct uart_port *port) |
697 | { |
698 | struct max3100_port *s = container_of(port, |
699 | struct max3100_port, |
700 | port); |
701 | |
702 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
703 | return 0; |
704 | } |
705 | |
706 | static void max3100_break_ctl(struct uart_port *port, int break_state) |
707 | { |
708 | struct max3100_port *s = container_of(port, |
709 | struct max3100_port, |
710 | port); |
711 | |
712 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
713 | } |
714 | |
715 | static struct uart_ops max3100_ops = { |
716 | .tx_empty = max3100_tx_empty, |
717 | .set_mctrl = max3100_set_mctrl, |
718 | .get_mctrl = max3100_get_mctrl, |
719 | .stop_tx = max3100_stop_tx, |
720 | .start_tx = max3100_start_tx, |
721 | .stop_rx = max3100_stop_rx, |
722 | .enable_ms = max3100_enable_ms, |
723 | .break_ctl = max3100_break_ctl, |
724 | .startup = max3100_startup, |
725 | .shutdown = max3100_shutdown, |
726 | .set_termios = max3100_set_termios, |
727 | .type = max3100_type, |
728 | .release_port = max3100_release_port, |
729 | .request_port = max3100_request_port, |
730 | .config_port = max3100_config_port, |
731 | .verify_port = max3100_verify_port, |
732 | }; |
733 | |
734 | static struct uart_driver max3100_uart_driver = { |
735 | .owner = THIS_MODULE, |
736 | .driver_name = "ttyMAX", |
737 | .dev_name = "ttyMAX", |
738 | .major = MAX3100_MAJOR, |
739 | .minor = MAX3100_MINOR, |
740 | .nr = MAX_MAX3100, |
741 | }; |
742 | static int uart_driver_registered; |
743 | |
744 | static int max3100_probe(struct spi_device *spi) |
745 | { |
746 | int i, retval; |
747 | struct plat_max3100 *pdata; |
748 | u16 tx, rx; |
749 | |
750 | mutex_lock(&max3100s_lock); |
751 | |
752 | if (!uart_driver_registered) { |
753 | uart_driver_registered = 1; |
754 | retval = uart_register_driver(&max3100_uart_driver); |
755 | if (retval) { |
756 | printk(KERN_ERR "Couldn't register max3100 uart driver\n"); |
757 | mutex_unlock(&max3100s_lock); |
758 | return retval; |
759 | } |
760 | } |
761 | |
762 | for (i = 0; i < MAX_MAX3100; i++) |
763 | if (!max3100s[i]) |
764 | break; |
765 | if (i == MAX_MAX3100) { |
766 | dev_warn(&spi->dev, "too many MAX3100 chips\n"); |
767 | mutex_unlock(&max3100s_lock); |
768 | return -ENOMEM; |
769 | } |
770 | |
771 | max3100s[i] = kzalloc(sizeof(struct max3100_port), GFP_KERNEL); |
772 | if (!max3100s[i]) { |
773 | dev_warn(&spi->dev, |
774 | "kmalloc for max3100 structure %d failed!\n", i); |
775 | mutex_unlock(&max3100s_lock); |
776 | return -ENOMEM; |
777 | } |
778 | max3100s[i]->spi = spi; |
779 | max3100s[i]->irq = spi->irq; |
780 | spin_lock_init(&max3100s[i]->conf_lock); |
781 | dev_set_drvdata(&spi->dev, max3100s[i]); |
782 | pdata = spi->dev.platform_data; |
783 | max3100s[i]->crystal = pdata->crystal; |
784 | max3100s[i]->loopback = pdata->loopback; |
785 | max3100s[i]->poll_time = pdata->poll_time * HZ / 1000; |
786 | if (pdata->poll_time > 0 && max3100s[i]->poll_time == 0) |
787 | max3100s[i]->poll_time = 1; |
788 | max3100s[i]->max3100_hw_suspend = pdata->max3100_hw_suspend; |
789 | max3100s[i]->minor = i; |
790 | init_timer(&max3100s[i]->timer); |
791 | max3100s[i]->timer.function = max3100_timeout; |
792 | max3100s[i]->timer.data = (unsigned long) max3100s[i]; |
793 | |
794 | dev_dbg(&spi->dev, "%s: adding port %d\n", __func__, i); |
795 | max3100s[i]->port.irq = max3100s[i]->irq; |
796 | max3100s[i]->port.uartclk = max3100s[i]->crystal ? 3686400 : 1843200; |
797 | max3100s[i]->port.fifosize = 16; |
798 | max3100s[i]->port.ops = &max3100_ops; |
799 | max3100s[i]->port.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF; |
800 | max3100s[i]->port.line = i; |
801 | max3100s[i]->port.type = PORT_MAX3100; |
802 | max3100s[i]->port.dev = &spi->dev; |
803 | retval = uart_add_one_port(&max3100_uart_driver, &max3100s[i]->port); |
804 | if (retval < 0) |
805 | dev_warn(&spi->dev, |
806 | "uart_add_one_port failed for line %d with error %d\n", |
807 | i, retval); |
808 | |
809 | /* set shutdown mode to save power. Will be woken-up on open */ |
810 | if (max3100s[i]->max3100_hw_suspend) |
811 | max3100s[i]->max3100_hw_suspend(1); |
812 | else { |
813 | tx = MAX3100_WC | MAX3100_SHDN; |
814 | max3100_sr(max3100s[i], tx, &rx); |
815 | } |
816 | mutex_unlock(&max3100s_lock); |
817 | return 0; |
818 | } |
819 | |
820 | static int max3100_remove(struct spi_device *spi) |
821 | { |
822 | struct max3100_port *s = dev_get_drvdata(&spi->dev); |
823 | int i; |
824 | |
825 | mutex_lock(&max3100s_lock); |
826 | |
827 | /* find out the index for the chip we are removing */ |
828 | for (i = 0; i < MAX_MAX3100; i++) |
829 | if (max3100s[i] == s) { |
830 | dev_dbg(&spi->dev, "%s: removing port %d\n", __func__, i); |
831 | uart_remove_one_port(&max3100_uart_driver, &max3100s[i]->port); |
832 | kfree(max3100s[i]); |
833 | max3100s[i] = NULL; |
834 | break; |
835 | } |
836 | |
837 | WARN_ON(i == MAX_MAX3100); |
838 | |
839 | /* check if this is the last chip we have */ |
840 | for (i = 0; i < MAX_MAX3100; i++) |
841 | if (max3100s[i]) { |
842 | mutex_unlock(&max3100s_lock); |
843 | return 0; |
844 | } |
845 | pr_debug("removing max3100 driver\n"); |
846 | uart_unregister_driver(&max3100_uart_driver); |
847 | |
848 | mutex_unlock(&max3100s_lock); |
849 | return 0; |
850 | } |
851 | |
852 | #ifdef CONFIG_PM |
853 | |
854 | static int max3100_suspend(struct spi_device *spi, pm_message_t state) |
855 | { |
856 | struct max3100_port *s = dev_get_drvdata(&spi->dev); |
857 | |
858 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
859 | |
860 | disable_irq(s->irq); |
861 | |
862 | s->suspending = 1; |
863 | uart_suspend_port(&max3100_uart_driver, &s->port); |
864 | |
865 | if (s->max3100_hw_suspend) |
866 | s->max3100_hw_suspend(1); |
867 | else { |
868 | /* no HW suspend, so do SW one */ |
869 | u16 tx, rx; |
870 | |
871 | tx = MAX3100_WC | MAX3100_SHDN; |
872 | max3100_sr(s, tx, &rx); |
873 | } |
874 | return 0; |
875 | } |
876 | |
877 | static int max3100_resume(struct spi_device *spi) |
878 | { |
879 | struct max3100_port *s = dev_get_drvdata(&spi->dev); |
880 | |
881 | dev_dbg(&s->spi->dev, "%s\n", __func__); |
882 | |
883 | if (s->max3100_hw_suspend) |
884 | s->max3100_hw_suspend(0); |
885 | uart_resume_port(&max3100_uart_driver, &s->port); |
886 | s->suspending = 0; |
887 | |
888 | enable_irq(s->irq); |
889 | |
890 | s->conf_commit = 1; |
891 | if (s->workqueue) |
892 | max3100_dowork(s); |
893 | |
894 | return 0; |
895 | } |
896 | |
897 | #else |
898 | #define max3100_suspend NULL |
899 | #define max3100_resume NULL |
900 | #endif |
901 | |
902 | static struct spi_driver max3100_driver = { |
903 | .driver = { |
904 | .name = "max3100", |
905 | .owner = THIS_MODULE, |
906 | }, |
907 | |
908 | .probe = max3100_probe, |
909 | .remove = max3100_remove, |
910 | .suspend = max3100_suspend, |
911 | .resume = max3100_resume, |
912 | }; |
913 | |
914 | module_spi_driver(max3100_driver); |
915 | |
916 | MODULE_DESCRIPTION("MAX3100 driver"); |
917 | MODULE_AUTHOR("Christian Pellegrin <chripell@evolware.org>"); |
918 | MODULE_LICENSE("GPL"); |
919 | MODULE_ALIAS("spi:max3100"); |
920 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9