aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/serial
diff options
context:
space:
mode:
authorAlan Cox <alan@lxorguk.ukuu.org.uk>2009-04-08 15:13:16 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2009-04-08 17:33:38 -0400
commit7831d56b0a3544cbb6f82f76c34ca95e24d5b676 (patch)
treedb1eced469d00a652009f0bff5fa9fd37c5bab1a /drivers/serial
parent3a709703538c471530405556dda136fd0d82b0dc (diff)
tty: MAX3100
Thou shalt remember to use 'git add' or errors shall be visited on your downloads and there shall be wrath from on list and much gnashing of teeth. Thou shalt remember to use git status or there shall be catcalls and much embarrasment shall come to pass. Signed-off-by: Alan "I'm hiding" Cox <alan@lxorguk.ukuu.org.uk> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Diffstat (limited to 'drivers/serial')
-rw-r--r--drivers/serial/max3100.c927
1 files changed, 927 insertions, 0 deletions
diff --git a/drivers/serial/max3100.c b/drivers/serial/max3100.c
new file mode 100644
index 000000000000..9fd33e5622bd
--- /dev/null
+++ b/drivers/serial/max3100.c
@@ -0,0 +1,927 @@
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/device.h>
45#include <linux/serial_core.h>
46#include <linux/serial.h>
47#include <linux/spi/spi.h>
48#include <linux/freezer.h>
49
50#include <linux/serial_max3100.h>
51
52#define MAX3100_C (1<<14)
53#define MAX3100_D (0<<14)
54#define MAX3100_W (1<<15)
55#define MAX3100_RX (0<<15)
56
57#define MAX3100_WC (MAX3100_W | MAX3100_C)
58#define MAX3100_RC (MAX3100_RX | MAX3100_C)
59#define MAX3100_WD (MAX3100_W | MAX3100_D)
60#define MAX3100_RD (MAX3100_RX | MAX3100_D)
61#define MAX3100_CMD (3 << 14)
62
63#define MAX3100_T (1<<14)
64#define MAX3100_R (1<<15)
65
66#define MAX3100_FEN (1<<13)
67#define MAX3100_SHDN (1<<12)
68#define MAX3100_TM (1<<11)
69#define MAX3100_RM (1<<10)
70#define MAX3100_PM (1<<9)
71#define MAX3100_RAM (1<<8)
72#define MAX3100_IR (1<<7)
73#define MAX3100_ST (1<<6)
74#define MAX3100_PE (1<<5)
75#define MAX3100_L (1<<4)
76#define MAX3100_BAUD (0xf)
77
78#define MAX3100_TE (1<<10)
79#define MAX3100_RAFE (1<<10)
80#define MAX3100_RTS (1<<9)
81#define MAX3100_CTS (1<<9)
82#define MAX3100_PT (1<<8)
83#define MAX3100_DATA (0xff)
84
85#define MAX3100_RT (MAX3100_R | MAX3100_T)
86#define MAX3100_RTC (MAX3100_RT | MAX3100_CTS | MAX3100_RAFE)
87
88/* the following simulate a status reg for ignore_status_mask */
89#define MAX3100_STATUS_PE 1
90#define MAX3100_STATUS_FE 2
91#define MAX3100_STATUS_OE 4
92
93struct max3100_port {
94 struct uart_port port;
95 struct spi_device *spi;
96
97 int cts; /* last CTS received for flow ctrl */
98 int tx_empty; /* last TX empty bit */
99
100 spinlock_t conf_lock; /* shared data */
101 int conf_commit; /* need to make changes */
102 int conf; /* configuration for the MAX31000
103 * (bits 0-7, bits 8-11 are irqs) */
104 int rts_commit; /* need to change rts */
105 int rts; /* rts status */
106 int baud; /* current baud rate */
107
108 int parity; /* keeps track if we should send parity */
109#define MAX3100_PARITY_ON 1
110#define MAX3100_PARITY_ODD 2
111#define MAX3100_7BIT 4
112 int rx_enabled; /* if we should rx chars */
113
114 int irq; /* irq assigned to the max3100 */
115
116 int minor; /* minor number */
117 int crystal; /* 1 if 3.6864Mhz crystal 0 for 1.8432 */
118 int loopback; /* 1 if we are in loopback mode */
119
120 /* for handling irqs: need workqueue since we do spi_sync */
121 struct workqueue_struct *workqueue;
122 struct work_struct work;
123 /* set to 1 to make the workhandler exit as soon as possible */
124 int force_end_work;
125 /* need to know we are suspending to avoid deadlock on workqueue */
126 int suspending;
127
128 /* hook for suspending MAX3100 via dedicated pin */
129 void (*max3100_hw_suspend) (int suspend);
130
131 /* poll time (in ms) for ctrl lines */
132 int poll_time;
133 /* and its timer */
134 struct timer_list timer;
135};
136
137static struct max3100_port *max3100s[MAX_MAX3100]; /* the chips */
138static DEFINE_MUTEX(max3100s_lock); /* race on probe */
139
140static int max3100_do_parity(struct max3100_port *s, u16 c)
141{
142 int parity;
143
144 if (s->parity & MAX3100_PARITY_ODD)
145 parity = 1;
146 else
147 parity = 0;
148
149 if (s->parity & MAX3100_7BIT)
150 c &= 0x7f;
151 else
152 c &= 0xff;
153
154 parity = parity ^ (hweight8(c) & 1);
155 return parity;
156}
157
158static int max3100_check_parity(struct max3100_port *s, u16 c)
159{
160 return max3100_do_parity(s, c) == ((c >> 8) & 1);
161}
162
163static void max3100_calc_parity(struct max3100_port *s, u16 *c)
164{
165 if (s->parity & MAX3100_7BIT)
166 *c &= 0x7f;
167 else
168 *c &= 0xff;
169
170 if (s->parity & MAX3100_PARITY_ON)
171 *c |= max3100_do_parity(s, *c) << 8;
172}
173
174static void max3100_work(struct work_struct *w);
175
176static void max3100_dowork(struct max3100_port *s)
177{
178 if (!s->force_end_work && !work_pending(&s->work) &&
179 !freezing(current) && !s->suspending)
180 queue_work(s->workqueue, &s->work);
181}
182
183static void max3100_timeout(unsigned long data)
184{
185 struct max3100_port *s = (struct max3100_port *)data;
186
187 if (s->port.info) {
188 max3100_dowork(s);
189 mod_timer(&s->timer, jiffies + s->poll_time);
190 }
191}
192
193static int max3100_sr(struct max3100_port *s, u16 tx, u16 *rx)
194{
195 struct spi_message message;
196 u16 etx, erx;
197 int status;
198 struct spi_transfer tran = {
199 .tx_buf = &etx,
200 .rx_buf = &erx,
201 .len = 2,
202 };
203
204 etx = cpu_to_be16(tx);
205 spi_message_init(&message);
206 spi_message_add_tail(&tran, &message);
207 status = spi_sync(s->spi, &message);
208 if (status) {
209 dev_warn(&s->spi->dev, "error while calling spi_sync\n");
210 return -EIO;
211 }
212 *rx = be16_to_cpu(erx);
213 s->tx_empty = (*rx & MAX3100_T) > 0;
214 dev_dbg(&s->spi->dev, "%04x - %04x\n", tx, *rx);
215 return 0;
216}
217
218static int max3100_handlerx(struct max3100_port *s, u16 rx)
219{
220 unsigned int ch, flg, status = 0;
221 int ret = 0, cts;
222
223 if (rx & MAX3100_R && s->rx_enabled) {
224 dev_dbg(&s->spi->dev, "%s\n", __func__);
225 ch = rx & (s->parity & MAX3100_7BIT ? 0x7f : 0xff);
226 if (rx & MAX3100_RAFE) {
227 s->port.icount.frame++;
228 flg = TTY_FRAME;
229 status |= MAX3100_STATUS_FE;
230 } else {
231 if (s->parity & MAX3100_PARITY_ON) {
232 if (max3100_check_parity(s, rx)) {
233 s->port.icount.rx++;
234 flg = TTY_NORMAL;
235 } else {
236 s->port.icount.parity++;
237 flg = TTY_PARITY;
238 status |= MAX3100_STATUS_PE;
239 }
240 } else {
241 s->port.icount.rx++;
242 flg = TTY_NORMAL;
243 }
244 }
245 uart_insert_char(&s->port, status, MAX3100_STATUS_OE, ch, flg);
246 ret = 1;
247 }
248
249 cts = (rx & MAX3100_CTS) > 0;
250 if (s->cts != cts) {
251 s->cts = cts;
252 uart_handle_cts_change(&s->port, cts ? TIOCM_CTS : 0);
253 }
254
255 return ret;
256}
257
258static void max3100_work(struct work_struct *w)
259{
260 struct max3100_port *s = container_of(w, struct max3100_port, work);
261 int rxchars;
262 u16 tx, rx;
263 int conf, cconf, rts, crts;
264 struct circ_buf *xmit = &s->port.info->xmit;
265
266 dev_dbg(&s->spi->dev, "%s\n", __func__);
267
268 rxchars = 0;
269 do {
270 spin_lock(&s->conf_lock);
271 conf = s->conf;
272 cconf = s->conf_commit;
273 s->conf_commit = 0;
274 rts = s->rts;
275 crts = s->rts_commit;
276 s->rts_commit = 0;
277 spin_unlock(&s->conf_lock);
278 if (cconf)
279 max3100_sr(s, MAX3100_WC | conf, &rx);
280 if (crts) {
281 max3100_sr(s, MAX3100_WD | MAX3100_TE |
282 (s->rts ? MAX3100_RTS : 0), &rx);
283 rxchars += max3100_handlerx(s, rx);
284 }
285
286 max3100_sr(s, MAX3100_RD, &rx);
287 rxchars += max3100_handlerx(s, rx);
288
289 if (rx & MAX3100_T) {
290 tx = 0xffff;
291 if (s->port.x_char) {
292 tx = s->port.x_char;
293 s->port.icount.tx++;
294 s->port.x_char = 0;
295 } else if (!uart_circ_empty(xmit) &&
296 !uart_tx_stopped(&s->port)) {
297 tx = xmit->buf[xmit->tail];
298 xmit->tail = (xmit->tail + 1) &
299 (UART_XMIT_SIZE - 1);
300 s->port.icount.tx++;
301 }
302 if (tx != 0xffff) {
303 max3100_calc_parity(s, &tx);
304 tx |= MAX3100_WD | (s->rts ? MAX3100_RTS : 0);
305 max3100_sr(s, tx, &rx);
306 rxchars += max3100_handlerx(s, rx);
307 }
308 }
309
310 if (rxchars > 16 && s->port.info->port.tty != NULL) {
311 tty_flip_buffer_push(s->port.info->port.tty);
312 rxchars = 0;
313 }
314 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
315 uart_write_wakeup(&s->port);
316
317 } while (!s->force_end_work &&
318 !freezing(current) &&
319 ((rx & MAX3100_R) ||
320 (!uart_circ_empty(xmit) &&
321 !uart_tx_stopped(&s->port))));
322
323 if (rxchars > 0 && s->port.info->port.tty != NULL)
324 tty_flip_buffer_push(s->port.info->port.tty);
325}
326
327static irqreturn_t max3100_irq(int irqno, void *dev_id)
328{
329 struct max3100_port *s = dev_id;
330
331 dev_dbg(&s->spi->dev, "%s\n", __func__);
332
333 max3100_dowork(s);
334 return IRQ_HANDLED;
335}
336
337static void max3100_enable_ms(struct uart_port *port)
338{
339 struct max3100_port *s = container_of(port,
340 struct max3100_port,
341 port);
342
343 if (s->poll_time > 0)
344 mod_timer(&s->timer, jiffies);
345 dev_dbg(&s->spi->dev, "%s\n", __func__);
346}
347
348static void max3100_start_tx(struct uart_port *port)
349{
350 struct max3100_port *s = container_of(port,
351 struct max3100_port,
352 port);
353
354 dev_dbg(&s->spi->dev, "%s\n", __func__);
355
356 max3100_dowork(s);
357}
358
359static void max3100_stop_rx(struct uart_port *port)
360{
361 struct max3100_port *s = container_of(port,
362 struct max3100_port,
363 port);
364
365 dev_dbg(&s->spi->dev, "%s\n", __func__);
366
367 s->rx_enabled = 0;
368 spin_lock(&s->conf_lock);
369 s->conf &= ~MAX3100_RM;
370 s->conf_commit = 1;
371 spin_unlock(&s->conf_lock);
372 max3100_dowork(s);
373}
374
375static unsigned int max3100_tx_empty(struct uart_port *port)
376{
377 struct max3100_port *s = container_of(port,
378 struct max3100_port,
379 port);
380
381 dev_dbg(&s->spi->dev, "%s\n", __func__);
382
383 /* may not be truly up-to-date */
384 max3100_dowork(s);
385 return s->tx_empty;
386}
387
388static unsigned int max3100_get_mctrl(struct uart_port *port)
389{
390 struct max3100_port *s = container_of(port,
391 struct max3100_port,
392 port);
393
394 dev_dbg(&s->spi->dev, "%s\n", __func__);
395
396 /* may not be truly up-to-date */
397 max3100_dowork(s);
398 /* always assert DCD and DSR since these lines are not wired */
399 return (s->cts ? TIOCM_CTS : 0) | TIOCM_DSR | TIOCM_CAR;
400}
401
402static void max3100_set_mctrl(struct uart_port *port, unsigned int mctrl)
403{
404 struct max3100_port *s = container_of(port,
405 struct max3100_port,
406 port);
407 int rts;
408
409 dev_dbg(&s->spi->dev, "%s\n", __func__);
410
411 rts = (mctrl & TIOCM_RTS) > 0;
412
413 spin_lock(&s->conf_lock);
414 if (s->rts != rts) {
415 s->rts = rts;
416 s->rts_commit = 1;
417 max3100_dowork(s);
418 }
419 spin_unlock(&s->conf_lock);
420}
421
422static void
423max3100_set_termios(struct uart_port *port, struct ktermios *termios,
424 struct ktermios *old)
425{
426 struct max3100_port *s = container_of(port,
427 struct max3100_port,
428 port);
429 int baud = 0;
430 unsigned cflag;
431 u32 param_new, param_mask, parity = 0;
432 struct tty_struct *tty = s->port.info->port.tty;
433
434 dev_dbg(&s->spi->dev, "%s\n", __func__);
435 if (!tty)
436 return;
437
438 cflag = termios->c_cflag;
439 param_new = 0;
440 param_mask = 0;
441
442 baud = tty_get_baud_rate(tty);
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_encode_baud_rate(tty, 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.info->port.tty->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
550static 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
585static 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_freezeable_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
640static 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
651static 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
660static 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
672static 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
687static 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
696static 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
706static 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
715static 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
734static 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};
742static int uart_driver_registered;
743
744static int __devinit 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
820static int __devexit 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 break;
831
832 dev_dbg(&spi->dev, "%s: removing port %d\n", __func__, i);
833 uart_remove_one_port(&max3100_uart_driver, &max3100s[i]->port);
834 kfree(max3100s[i]);
835 max3100s[i] = NULL;
836
837 /* check if this is the last chip we have */
838 for (i = 0; i < MAX_MAX3100; i++)
839 if (max3100s[i]) {
840 mutex_unlock(&max3100s_lock);
841 return 0;
842 }
843 pr_debug("removing max3100 driver\n");
844 uart_unregister_driver(&max3100_uart_driver);
845
846 mutex_unlock(&max3100s_lock);
847 return 0;
848}
849
850#ifdef CONFIG_PM
851
852static int max3100_suspend(struct spi_device *spi, pm_message_t state)
853{
854 struct max3100_port *s = dev_get_drvdata(&spi->dev);
855
856 dev_dbg(&s->spi->dev, "%s\n", __func__);
857
858 disable_irq(s->irq);
859
860 s->suspending = 1;
861 uart_suspend_port(&max3100_uart_driver, &s->port);
862
863 if (s->max3100_hw_suspend)
864 s->max3100_hw_suspend(1);
865 else {
866 /* no HW suspend, so do SW one */
867 u16 tx, rx;
868
869 tx = MAX3100_WC | MAX3100_SHDN;
870 max3100_sr(s, tx, &rx);
871 }
872 return 0;
873}
874
875static int max3100_resume(struct spi_device *spi)
876{
877 struct max3100_port *s = dev_get_drvdata(&spi->dev);
878
879 dev_dbg(&s->spi->dev, "%s\n", __func__);
880
881 if (s->max3100_hw_suspend)
882 s->max3100_hw_suspend(0);
883 uart_resume_port(&max3100_uart_driver, &s->port);
884 s->suspending = 0;
885
886 enable_irq(s->irq);
887
888 s->conf_commit = 1;
889 if (s->workqueue)
890 max3100_dowork(s);
891
892 return 0;
893}
894
895#else
896#define max3100_suspend NULL
897#define max3100_resume NULL
898#endif
899
900static struct spi_driver max3100_driver = {
901 .driver = {
902 .name = "max3100",
903 .bus = &spi_bus_type,
904 .owner = THIS_MODULE,
905 },
906
907 .probe = max3100_probe,
908 .remove = __devexit_p(max3100_remove),
909 .suspend = max3100_suspend,
910 .resume = max3100_resume,
911};
912
913static int __init max3100_init(void)
914{
915 return spi_register_driver(&max3100_driver);
916}
917module_init(max3100_init);
918
919static void __exit max3100_exit(void)
920{
921 spi_unregister_driver(&max3100_driver);
922}
923module_exit(max3100_exit);
924
925MODULE_DESCRIPTION("MAX3100 driver");
926MODULE_AUTHOR("Christian Pellegrin <chripell@evolware.org>");
927MODULE_LICENSE("GPL");