Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
max3100.c
Go to the documentation of this file.
1 /*
2  *
3  * Copyright (C) 2008 Christian Pellegrin <[email protected]>
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 && !work_pending(&s->work) &&
183  !freezing(current) && !s->suspending)
184  queue_work(s->workqueue, &s->work);
185 }
186 
187 static void max3100_timeout(unsigned long data)
188 {
189  struct max3100_port *s = (struct max3100_port *)data;
190 
191  if (s->port.state) {
192  max3100_dowork(s);
193  mod_timer(&s->timer, jiffies + s->poll_time);
194  }
195 }
196 
197 static int max3100_sr(struct max3100_port *s, u16 tx, u16 *rx)
198 {
199  struct spi_message message;
200  u16 etx, erx;
201  int status;
202  struct spi_transfer tran = {
203  .tx_buf = &etx,
204  .rx_buf = &erx,
205  .len = 2,
206  };
207 
208  etx = cpu_to_be16(tx);
209  spi_message_init(&message);
210  spi_message_add_tail(&tran, &message);
211  status = spi_sync(s->spi, &message);
212  if (status) {
213  dev_warn(&s->spi->dev, "error while calling spi_sync\n");
214  return -EIO;
215  }
216  *rx = be16_to_cpu(erx);
217  s->tx_empty = (*rx & MAX3100_T) > 0;
218  dev_dbg(&s->spi->dev, "%04x - %04x\n", tx, *rx);
219  return 0;
220 }
221 
222 static int max3100_handlerx(struct max3100_port *s, u16 rx)
223 {
224  unsigned int ch, flg, status = 0;
225  int ret = 0, cts;
226 
227  if (rx & MAX3100_R && s->rx_enabled) {
228  dev_dbg(&s->spi->dev, "%s\n", __func__);
229  ch = rx & (s->parity & MAX3100_7BIT ? 0x7f : 0xff);
230  if (rx & MAX3100_RAFE) {
231  s->port.icount.frame++;
232  flg = TTY_FRAME;
233  status |= MAX3100_STATUS_FE;
234  } else {
235  if (s->parity & MAX3100_PARITY_ON) {
236  if (max3100_check_parity(s, rx)) {
237  s->port.icount.rx++;
238  flg = TTY_NORMAL;
239  } else {
240  s->port.icount.parity++;
241  flg = TTY_PARITY;
242  status |= MAX3100_STATUS_PE;
243  }
244  } else {
245  s->port.icount.rx++;
246  flg = TTY_NORMAL;
247  }
248  }
249  uart_insert_char(&s->port, status, MAX3100_STATUS_OE, ch, flg);
250  ret = 1;
251  }
252 
253  cts = (rx & MAX3100_CTS) > 0;
254  if (s->cts != cts) {
255  s->cts = cts;
256  uart_handle_cts_change(&s->port, cts ? TIOCM_CTS : 0);
257  }
258 
259  return ret;
260 }
261 
262 static void max3100_work(struct work_struct *w)
263 {
264  struct max3100_port *s = container_of(w, struct max3100_port, work);
265  int rxchars;
266  u16 tx, rx;
267  int conf, cconf, rts, crts;
268  struct circ_buf *xmit = &s->port.state->xmit;
269 
270  dev_dbg(&s->spi->dev, "%s\n", __func__);
271 
272  rxchars = 0;
273  do {
274  spin_lock(&s->conf_lock);
275  conf = s->conf;
276  cconf = s->conf_commit;
277  s->conf_commit = 0;
278  rts = s->rts;
279  crts = s->rts_commit;
280  s->rts_commit = 0;
281  spin_unlock(&s->conf_lock);
282  if (cconf)
283  max3100_sr(s, MAX3100_WC | conf, &rx);
284  if (crts) {
285  max3100_sr(s, MAX3100_WD | MAX3100_TE |
286  (s->rts ? MAX3100_RTS : 0), &rx);
287  rxchars += max3100_handlerx(s, rx);
288  }
289 
290  max3100_sr(s, MAX3100_RD, &rx);
291  rxchars += max3100_handlerx(s, rx);
292 
293  if (rx & MAX3100_T) {
294  tx = 0xffff;
295  if (s->port.x_char) {
296  tx = s->port.x_char;
297  s->port.icount.tx++;
298  s->port.x_char = 0;
299  } else if (!uart_circ_empty(xmit) &&
300  !uart_tx_stopped(&s->port)) {
301  tx = xmit->buf[xmit->tail];
302  xmit->tail = (xmit->tail + 1) &
303  (UART_XMIT_SIZE - 1);
304  s->port.icount.tx++;
305  }
306  if (tx != 0xffff) {
307  max3100_calc_parity(s, &tx);
308  tx |= MAX3100_WD | (s->rts ? MAX3100_RTS : 0);
309  max3100_sr(s, tx, &rx);
310  rxchars += max3100_handlerx(s, rx);
311  }
312  }
313 
314  if (rxchars > 16 && s->port.state->port.tty != NULL) {
315  tty_flip_buffer_push(s->port.state->port.tty);
316  rxchars = 0;
317  }
318  if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
319  uart_write_wakeup(&s->port);
320 
321  } while (!s->force_end_work &&
322  !freezing(current) &&
323  ((rx & MAX3100_R) ||
324  (!uart_circ_empty(xmit) &&
325  !uart_tx_stopped(&s->port))));
326 
327  if (rxchars > 0 && s->port.state->port.tty != NULL)
328  tty_flip_buffer_push(s->port.state->port.tty);
329 }
330 
331 static irqreturn_t max3100_irq(int irqno, void *dev_id)
332 {
333  struct max3100_port *s = dev_id;
334 
335  dev_dbg(&s->spi->dev, "%s\n", __func__);
336 
337  max3100_dowork(s);
338  return IRQ_HANDLED;
339 }
340 
341 static void max3100_enable_ms(struct uart_port *port)
342 {
343  struct max3100_port *s = container_of(port,
344  struct max3100_port,
345  port);
346 
347  if (s->poll_time > 0)
348  mod_timer(&s->timer, jiffies);
349  dev_dbg(&s->spi->dev, "%s\n", __func__);
350 }
351 
352 static void max3100_start_tx(struct uart_port *port)
353 {
354  struct max3100_port *s = container_of(port,
355  struct max3100_port,
356  port);
357 
358  dev_dbg(&s->spi->dev, "%s\n", __func__);
359 
360  max3100_dowork(s);
361 }
362 
363 static void max3100_stop_rx(struct uart_port *port)
364 {
365  struct max3100_port *s = container_of(port,
366  struct max3100_port,
367  port);
368 
369  dev_dbg(&s->spi->dev, "%s\n", __func__);
370 
371  s->rx_enabled = 0;
372  spin_lock(&s->conf_lock);
373  s->conf &= ~MAX3100_RM;
374  s->conf_commit = 1;
375  spin_unlock(&s->conf_lock);
376  max3100_dowork(s);
377 }
378 
379 static unsigned int max3100_tx_empty(struct uart_port *port)
380 {
381  struct max3100_port *s = container_of(port,
382  struct max3100_port,
383  port);
384 
385  dev_dbg(&s->spi->dev, "%s\n", __func__);
386 
387  /* may not be truly up-to-date */
388  max3100_dowork(s);
389  return s->tx_empty;
390 }
391 
392 static unsigned int max3100_get_mctrl(struct uart_port *port)
393 {
394  struct max3100_port *s = container_of(port,
395  struct max3100_port,
396  port);
397 
398  dev_dbg(&s->spi->dev, "%s\n", __func__);
399 
400  /* may not be truly up-to-date */
401  max3100_dowork(s);
402  /* always assert DCD and DSR since these lines are not wired */
403  return (s->cts ? TIOCM_CTS : 0) | TIOCM_DSR | TIOCM_CAR;
404 }
405 
406 static void max3100_set_mctrl(struct uart_port *port, unsigned int mctrl)
407 {
408  struct max3100_port *s = container_of(port,
409  struct max3100_port,
410  port);
411  int rts;
412 
413  dev_dbg(&s->spi->dev, "%s\n", __func__);
414 
415  rts = (mctrl & TIOCM_RTS) > 0;
416 
417  spin_lock(&s->conf_lock);
418  if (s->rts != rts) {
419  s->rts = rts;
420  s->rts_commit = 1;
421  max3100_dowork(s);
422  }
423  spin_unlock(&s->conf_lock);
424 }
425 
426 static void
427 max3100_set_termios(struct uart_port *port, struct ktermios *termios,
428  struct ktermios *old)
429 {
430  struct max3100_port *s = container_of(port,
431  struct max3100_port,
432  port);
433  int baud = 0;
434  unsigned cflag;
435  u32 param_new, param_mask, parity = 0;
436 
437  dev_dbg(&s->spi->dev, "%s\n", __func__);
438 
439  cflag = termios->c_cflag;
440  param_new = 0;
441  param_mask = 0;
442 
443  baud = tty_termios_baud_rate(termios);
444  param_new = s->conf & MAX3100_BAUD;
445  switch (baud) {
446  case 300:
447  if (s->crystal)
448  baud = s->baud;
449  else
450  param_new = 15;
451  break;
452  case 600:
453  param_new = 14 + s->crystal;
454  break;
455  case 1200:
456  param_new = 13 + s->crystal;
457  break;
458  case 2400:
459  param_new = 12 + s->crystal;
460  break;
461  case 4800:
462  param_new = 11 + s->crystal;
463  break;
464  case 9600:
465  param_new = 10 + s->crystal;
466  break;
467  case 19200:
468  param_new = 9 + s->crystal;
469  break;
470  case 38400:
471  param_new = 8 + s->crystal;
472  break;
473  case 57600:
474  param_new = 1 + s->crystal;
475  break;
476  case 115200:
477  param_new = 0 + s->crystal;
478  break;
479  case 230400:
480  if (s->crystal)
481  param_new = 0;
482  else
483  baud = s->baud;
484  break;
485  default:
486  baud = s->baud;
487  }
488  tty_termios_encode_baud_rate(termios, baud, baud);
489  s->baud = baud;
490  param_mask |= MAX3100_BAUD;
491 
492  if ((cflag & CSIZE) == CS8) {
493  param_new &= ~MAX3100_L;
494  parity &= ~MAX3100_7BIT;
495  } else {
496  param_new |= MAX3100_L;
497  parity |= MAX3100_7BIT;
498  cflag = (cflag & ~CSIZE) | CS7;
499  }
500  param_mask |= MAX3100_L;
501 
502  if (cflag & CSTOPB)
503  param_new |= MAX3100_ST;
504  else
505  param_new &= ~MAX3100_ST;
506  param_mask |= MAX3100_ST;
507 
508  if (cflag & PARENB) {
509  param_new |= MAX3100_PE;
510  parity |= MAX3100_PARITY_ON;
511  } else {
512  param_new &= ~MAX3100_PE;
513  parity &= ~MAX3100_PARITY_ON;
514  }
515  param_mask |= MAX3100_PE;
516 
517  if (cflag & PARODD)
518  parity |= MAX3100_PARITY_ODD;
519  else
520  parity &= ~MAX3100_PARITY_ODD;
521 
522  /* mask termios capabilities we don't support */
523  cflag &= ~CMSPAR;
524  termios->c_cflag = cflag;
525 
526  s->port.ignore_status_mask = 0;
527  if (termios->c_iflag & IGNPAR)
528  s->port.ignore_status_mask |=
529  MAX3100_STATUS_PE | MAX3100_STATUS_FE |
530  MAX3100_STATUS_OE;
531 
532  /* we are sending char from a workqueue so enable */
533  s->port.state->port.tty->low_latency = 1;
534 
535  if (s->poll_time > 0)
536  del_timer_sync(&s->timer);
537 
538  uart_update_timeout(port, termios->c_cflag, baud);
539 
540  spin_lock(&s->conf_lock);
541  s->conf = (s->conf & ~param_mask) | (param_new & param_mask);
542  s->conf_commit = 1;
543  s->parity = parity;
544  spin_unlock(&s->conf_lock);
545  max3100_dowork(s);
546 
547  if (UART_ENABLE_MS(&s->port, termios->c_cflag))
548  max3100_enable_ms(&s->port);
549 }
550 
551 static void max3100_shutdown(struct uart_port *port)
552 {
553  struct max3100_port *s = container_of(port,
554  struct max3100_port,
555  port);
556 
557  dev_dbg(&s->spi->dev, "%s\n", __func__);
558 
559  if (s->suspending)
560  return;
561 
562  s->force_end_work = 1;
563 
564  if (s->poll_time > 0)
565  del_timer_sync(&s->timer);
566 
567  if (s->workqueue) {
568  flush_workqueue(s->workqueue);
569  destroy_workqueue(s->workqueue);
570  s->workqueue = NULL;
571  }
572  if (s->irq)
573  free_irq(s->irq, s);
574 
575  /* set shutdown mode to save power */
576  if (s->max3100_hw_suspend)
577  s->max3100_hw_suspend(1);
578  else {
579  u16 tx, rx;
580 
581  tx = MAX3100_WC | MAX3100_SHDN;
582  max3100_sr(s, tx, &rx);
583  }
584 }
585 
586 static int max3100_startup(struct uart_port *port)
587 {
588  struct max3100_port *s = container_of(port,
589  struct max3100_port,
590  port);
591  char b[12];
592 
593  dev_dbg(&s->spi->dev, "%s\n", __func__);
594 
595  s->conf = MAX3100_RM;
596  s->baud = s->crystal ? 230400 : 115200;
597  s->rx_enabled = 1;
598 
599  if (s->suspending)
600  return 0;
601 
602  s->force_end_work = 0;
603  s->parity = 0;
604  s->rts = 0;
605 
606  sprintf(b, "max3100-%d", s->minor);
607  s->workqueue = create_freezable_workqueue(b);
608  if (!s->workqueue) {
609  dev_warn(&s->spi->dev, "cannot create workqueue\n");
610  return -EBUSY;
611  }
612  INIT_WORK(&s->work, max3100_work);
613 
614  if (request_irq(s->irq, max3100_irq,
615  IRQF_TRIGGER_FALLING, "max3100", s) < 0) {
616  dev_warn(&s->spi->dev, "cannot allocate irq %d\n", s->irq);
617  s->irq = 0;
618  destroy_workqueue(s->workqueue);
619  s->workqueue = NULL;
620  return -EBUSY;
621  }
622 
623  if (s->loopback) {
624  u16 tx, rx;
625  tx = 0x4001;
626  max3100_sr(s, tx, &rx);
627  }
628 
629  if (s->max3100_hw_suspend)
630  s->max3100_hw_suspend(0);
631  s->conf_commit = 1;
632  max3100_dowork(s);
633  /* wait for clock to settle */
634  msleep(50);
635 
636  max3100_enable_ms(&s->port);
637 
638  return 0;
639 }
640 
641 static const char *max3100_type(struct uart_port *port)
642 {
643  struct max3100_port *s = container_of(port,
644  struct max3100_port,
645  port);
646 
647  dev_dbg(&s->spi->dev, "%s\n", __func__);
648 
649  return s->port.type == PORT_MAX3100 ? "MAX3100" : NULL;
650 }
651 
652 static void max3100_release_port(struct uart_port *port)
653 {
654  struct max3100_port *s = container_of(port,
655  struct max3100_port,
656  port);
657 
658  dev_dbg(&s->spi->dev, "%s\n", __func__);
659 }
660 
661 static void max3100_config_port(struct uart_port *port, int flags)
662 {
663  struct max3100_port *s = container_of(port,
664  struct max3100_port,
665  port);
666 
667  dev_dbg(&s->spi->dev, "%s\n", __func__);
668 
669  if (flags & UART_CONFIG_TYPE)
670  s->port.type = PORT_MAX3100;
671 }
672 
673 static int max3100_verify_port(struct uart_port *port,
674  struct serial_struct *ser)
675 {
676  struct max3100_port *s = container_of(port,
677  struct max3100_port,
678  port);
679  int ret = -EINVAL;
680 
681  dev_dbg(&s->spi->dev, "%s\n", __func__);
682 
683  if (ser->type == PORT_UNKNOWN || ser->type == PORT_MAX3100)
684  ret = 0;
685  return ret;
686 }
687 
688 static void max3100_stop_tx(struct uart_port *port)
689 {
690  struct max3100_port *s = container_of(port,
691  struct max3100_port,
692  port);
693 
694  dev_dbg(&s->spi->dev, "%s\n", __func__);
695 }
696 
697 static int max3100_request_port(struct uart_port *port)
698 {
699  struct max3100_port *s = container_of(port,
700  struct max3100_port,
701  port);
702 
703  dev_dbg(&s->spi->dev, "%s\n", __func__);
704  return 0;
705 }
706 
707 static void max3100_break_ctl(struct uart_port *port, int break_state)
708 {
709  struct max3100_port *s = container_of(port,
710  struct max3100_port,
711  port);
712 
713  dev_dbg(&s->spi->dev, "%s\n", __func__);
714 }
715 
716 static struct uart_ops max3100_ops = {
717  .tx_empty = max3100_tx_empty,
718  .set_mctrl = max3100_set_mctrl,
719  .get_mctrl = max3100_get_mctrl,
720  .stop_tx = max3100_stop_tx,
721  .start_tx = max3100_start_tx,
722  .stop_rx = max3100_stop_rx,
723  .enable_ms = max3100_enable_ms,
724  .break_ctl = max3100_break_ctl,
725  .startup = max3100_startup,
726  .shutdown = max3100_shutdown,
727  .set_termios = max3100_set_termios,
728  .type = max3100_type,
729  .release_port = max3100_release_port,
730  .request_port = max3100_request_port,
731  .config_port = max3100_config_port,
732  .verify_port = max3100_verify_port,
733 };
734 
735 static struct uart_driver max3100_uart_driver = {
736  .owner = THIS_MODULE,
737  .driver_name = "ttyMAX",
738  .dev_name = "ttyMAX",
739  .major = MAX3100_MAJOR,
740  .minor = MAX3100_MINOR,
741  .nr = MAX_MAX3100,
742 };
743 static int uart_driver_registered;
744 
745 static int __devinit max3100_probe(struct spi_device *spi)
746 {
747  int i, retval;
748  struct plat_max3100 *pdata;
749  u16 tx, rx;
750 
751  mutex_lock(&max3100s_lock);
752 
753  if (!uart_driver_registered) {
754  uart_driver_registered = 1;
755  retval = uart_register_driver(&max3100_uart_driver);
756  if (retval) {
757  printk(KERN_ERR "Couldn't register max3100 uart driver\n");
758  mutex_unlock(&max3100s_lock);
759  return retval;
760  }
761  }
762 
763  for (i = 0; i < MAX_MAX3100; i++)
764  if (!max3100s[i])
765  break;
766  if (i == MAX_MAX3100) {
767  dev_warn(&spi->dev, "too many MAX3100 chips\n");
768  mutex_unlock(&max3100s_lock);
769  return -ENOMEM;
770  }
771 
772  max3100s[i] = kzalloc(sizeof(struct max3100_port), GFP_KERNEL);
773  if (!max3100s[i]) {
774  dev_warn(&spi->dev,
775  "kmalloc for max3100 structure %d failed!\n", i);
776  mutex_unlock(&max3100s_lock);
777  return -ENOMEM;
778  }
779  max3100s[i]->spi = spi;
780  max3100s[i]->irq = spi->irq;
781  spin_lock_init(&max3100s[i]->conf_lock);
782  dev_set_drvdata(&spi->dev, max3100s[i]);
783  pdata = spi->dev.platform_data;
784  max3100s[i]->crystal = pdata->crystal;
785  max3100s[i]->loopback = pdata->loopback;
786  max3100s[i]->poll_time = pdata->poll_time * HZ / 1000;
787  if (pdata->poll_time > 0 && max3100s[i]->poll_time == 0)
788  max3100s[i]->poll_time = 1;
789  max3100s[i]->max3100_hw_suspend = pdata->max3100_hw_suspend;
790  max3100s[i]->minor = i;
791  init_timer(&max3100s[i]->timer);
792  max3100s[i]->timer.function = max3100_timeout;
793  max3100s[i]->timer.data = (unsigned long) max3100s[i];
794 
795  dev_dbg(&spi->dev, "%s: adding port %d\n", __func__, i);
796  max3100s[i]->port.irq = max3100s[i]->irq;
797  max3100s[i]->port.uartclk = max3100s[i]->crystal ? 3686400 : 1843200;
798  max3100s[i]->port.fifosize = 16;
799  max3100s[i]->port.ops = &max3100_ops;
800  max3100s[i]->port.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF;
801  max3100s[i]->port.line = i;
802  max3100s[i]->port.type = PORT_MAX3100;
803  max3100s[i]->port.dev = &spi->dev;
804  retval = uart_add_one_port(&max3100_uart_driver, &max3100s[i]->port);
805  if (retval < 0)
806  dev_warn(&spi->dev,
807  "uart_add_one_port failed for line %d with error %d\n",
808  i, retval);
809 
810  /* set shutdown mode to save power. Will be woken-up on open */
811  if (max3100s[i]->max3100_hw_suspend)
812  max3100s[i]->max3100_hw_suspend(1);
813  else {
814  tx = MAX3100_WC | MAX3100_SHDN;
815  max3100_sr(max3100s[i], tx, &rx);
816  }
817  mutex_unlock(&max3100s_lock);
818  return 0;
819 }
820 
821 static int __devexit max3100_remove(struct spi_device *spi)
822 {
823  struct max3100_port *s = dev_get_drvdata(&spi->dev);
824  int i;
825 
826  mutex_lock(&max3100s_lock);
827 
828  /* find out the index for the chip we are removing */
829  for (i = 0; i < MAX_MAX3100; i++)
830  if (max3100s[i] == s) {
831  dev_dbg(&spi->dev, "%s: removing port %d\n", __func__, i);
832  uart_remove_one_port(&max3100_uart_driver, &max3100s[i]->port);
833  kfree(max3100s[i]);
834  max3100s[i] = NULL;
835  break;
836  }
837 
838  WARN_ON(i == MAX_MAX3100);
839 
840  /* check if this is the last chip we have */
841  for (i = 0; i < MAX_MAX3100; i++)
842  if (max3100s[i]) {
843  mutex_unlock(&max3100s_lock);
844  return 0;
845  }
846  pr_debug("removing max3100 driver\n");
847  uart_unregister_driver(&max3100_uart_driver);
848 
849  mutex_unlock(&max3100s_lock);
850  return 0;
851 }
852 
853 #ifdef CONFIG_PM
854 
855 static int max3100_suspend(struct spi_device *spi, pm_message_t state)
856 {
857  struct max3100_port *s = dev_get_drvdata(&spi->dev);
858 
859  dev_dbg(&s->spi->dev, "%s\n", __func__);
860 
861  disable_irq(s->irq);
862 
863  s->suspending = 1;
864  uart_suspend_port(&max3100_uart_driver, &s->port);
865 
866  if (s->max3100_hw_suspend)
867  s->max3100_hw_suspend(1);
868  else {
869  /* no HW suspend, so do SW one */
870  u16 tx, rx;
871 
872  tx = MAX3100_WC | MAX3100_SHDN;
873  max3100_sr(s, tx, &rx);
874  }
875  return 0;
876 }
877 
878 static int max3100_resume(struct spi_device *spi)
879 {
880  struct max3100_port *s = dev_get_drvdata(&spi->dev);
881 
882  dev_dbg(&s->spi->dev, "%s\n", __func__);
883 
884  if (s->max3100_hw_suspend)
885  s->max3100_hw_suspend(0);
886  uart_resume_port(&max3100_uart_driver, &s->port);
887  s->suspending = 0;
888 
889  enable_irq(s->irq);
890 
891  s->conf_commit = 1;
892  if (s->workqueue)
893  max3100_dowork(s);
894 
895  return 0;
896 }
897 
898 #else
899 #define max3100_suspend NULL
900 #define max3100_resume NULL
901 #endif
902 
903 static struct spi_driver max3100_driver = {
904  .driver = {
905  .name = "max3100",
906  .owner = THIS_MODULE,
907  },
908 
909  .probe = max3100_probe,
910  .remove = __devexit_p(max3100_remove),
911  .suspend = max3100_suspend,
912  .resume = max3100_resume,
913 };
914 
915 module_spi_driver(max3100_driver);
916 
917 MODULE_DESCRIPTION("MAX3100 driver");
918 MODULE_AUTHOR("Christian Pellegrin <[email protected]>");
919 MODULE_LICENSE("GPL");
920 MODULE_ALIAS("spi:max3100");
Generated on Thu Jan 10 2013 14:34:34 for Linux Kernel by   doxygen 1.8.2