Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ifx6x60.c
Go to the documentation of this file.
1 /****************************************************************************
2  *
3  * Driver for the IFX 6x60 spi modem.
4  *
5  * Copyright (C) 2008 Option International
6  * Copyright (C) 2008 Filip Aben <[email protected]>
7  * Denis Joseph Barrow <[email protected]>
8  * Jan Dumon <[email protected]>
9  *
10  * Copyright (C) 2009, 2010 Intel Corp
11  * Russ Gorby <[email protected]>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License version 2 as
15  * published by the Free Software Foundation.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
25  * USA
26  *
27  * Driver modified by Intel from Option gtm501l_spi.c
28  *
29  * Notes
30  * o The driver currently assumes a single device only. If you need to
31  * change this then look for saved_ifx_dev and add a device lookup
32  * o The driver is intended to be big-endian safe but has never been
33  * tested that way (no suitable hardware). There are a couple of FIXME
34  * notes by areas that may need addressing
35  * o Some of the GPIO naming/setup assumptions may need revisiting if
36  * you need to use this driver for another platform.
37  *
38  *****************************************************************************/
39 #include <linux/dma-mapping.h>
40 #include <linux/module.h>
41 #include <linux/termios.h>
42 #include <linux/tty.h>
43 #include <linux/device.h>
44 #include <linux/spi/spi.h>
45 #include <linux/kfifo.h>
46 #include <linux/tty_flip.h>
47 #include <linux/timer.h>
48 #include <linux/serial.h>
49 #include <linux/interrupt.h>
50 #include <linux/irq.h>
51 #include <linux/rfkill.h>
52 #include <linux/fs.h>
53 #include <linux/ip.h>
54 #include <linux/dmapool.h>
55 #include <linux/gpio.h>
56 #include <linux/sched.h>
57 #include <linux/time.h>
58 #include <linux/wait.h>
59 #include <linux/pm.h>
60 #include <linux/pm_runtime.h>
61 #include <linux/spi/ifx_modem.h>
62 #include <linux/delay.h>
63 
64 #include "ifx6x60.h"
65 
66 #define IFX_SPI_MORE_MASK 0x10
67 #define IFX_SPI_MORE_BIT 12 /* bit position in u16 */
68 #define IFX_SPI_CTS_BIT 13 /* bit position in u16 */
69 #define IFX_SPI_MODE SPI_MODE_1
70 #define IFX_SPI_TTY_ID 0
71 #define IFX_SPI_TIMEOUT_SEC 2
72 #define IFX_SPI_HEADER_0 (-1)
73 #define IFX_SPI_HEADER_F (-2)
74 
75 /* forward reference */
76 static void ifx_spi_handle_srdy(struct ifx_spi_device *ifx_dev);
77 
78 /* local variables */
79 static int spi_bpw = 16; /* 8, 16 or 32 bit word length */
80 static struct tty_driver *tty_drv;
81 static struct ifx_spi_device *saved_ifx_dev;
82 static struct lock_class_key ifx_spi_key;
83 
84 /* GPIO/GPE settings */
85 
91 static inline void mrdy_set_high(struct ifx_spi_device *ifx)
92 {
93  gpio_set_value(ifx->gpio.mrdy, 1);
94 }
95 
101 static inline void mrdy_set_low(struct ifx_spi_device *ifx)
102 {
103  gpio_set_value(ifx->gpio.mrdy, 0);
104 }
105 
113 static void
114 ifx_spi_power_state_set(struct ifx_spi_device *ifx_dev, unsigned char val)
115 {
116  unsigned long flags;
117 
118  spin_lock_irqsave(&ifx_dev->power_lock, flags);
119 
120  /*
121  * if power status is already non-0, just update, else
122  * tell power system
123  */
124  if (!ifx_dev->power_status)
125  pm_runtime_get(&ifx_dev->spi_dev->dev);
126  ifx_dev->power_status |= val;
127 
128  spin_unlock_irqrestore(&ifx_dev->power_lock, flags);
129 }
130 
138 static void
139 ifx_spi_power_state_clear(struct ifx_spi_device *ifx_dev, unsigned char val)
140 {
141  unsigned long flags;
142 
143  spin_lock_irqsave(&ifx_dev->power_lock, flags);
144 
145  if (ifx_dev->power_status) {
146  ifx_dev->power_status &= ~val;
147  if (!ifx_dev->power_status)
148  pm_runtime_put(&ifx_dev->spi_dev->dev);
149  }
150 
151  spin_unlock_irqrestore(&ifx_dev->power_lock, flags);
152 }
153 
162 static inline void swap_buf(u16 *buf, int len, void *end)
163 {
164  int n;
165 
166  len = ((len + 1) >> 1);
167  if ((void *)&buf[len] > end) {
168  pr_err("swap_buf: swap exceeds boundary (%p > %p)!",
169  &buf[len], end);
170  return;
171  }
172  for (n = 0; n < len; n++) {
173  *buf = cpu_to_be16(*buf);
174  buf++;
175  }
176 }
177 
187 static void mrdy_assert(struct ifx_spi_device *ifx_dev)
188 {
189  int val = gpio_get_value(ifx_dev->gpio.srdy);
190  if (!val) {
192  &ifx_dev->flags)) {
193  ifx_dev->spi_timer.expires =
195  add_timer(&ifx_dev->spi_timer);
196 
197  }
198  }
199  ifx_spi_power_state_set(ifx_dev, IFX_SPI_POWER_DATA_PENDING);
200  mrdy_set_high(ifx_dev);
201 }
202 
210 static void ifx_spi_ttyhangup(struct ifx_spi_device *ifx_dev)
211 {
212  struct tty_port *pport = &ifx_dev->tty_port;
213  struct tty_struct *tty = tty_port_tty_get(pport);
214  if (tty) {
215  tty_hangup(tty);
216  tty_kref_put(tty);
217  }
218 }
219 
227 static void ifx_spi_timeout(unsigned long arg)
228 {
229  struct ifx_spi_device *ifx_dev = (struct ifx_spi_device *)arg;
230 
231  dev_warn(&ifx_dev->spi_dev->dev, "*** SPI Timeout ***");
232  ifx_spi_ttyhangup(ifx_dev);
233  mrdy_set_low(ifx_dev);
235 }
236 
237 /* char/tty operations */
238 
247 static int ifx_spi_tiocmget(struct tty_struct *tty)
248 {
249  unsigned int value;
250  struct ifx_spi_device *ifx_dev = tty->driver_data;
251 
252  value =
253  (test_bit(IFX_SPI_RTS, &ifx_dev->signal_state) ? TIOCM_RTS : 0) |
254  (test_bit(IFX_SPI_DTR, &ifx_dev->signal_state) ? TIOCM_DTR : 0) |
255  (test_bit(IFX_SPI_CTS, &ifx_dev->signal_state) ? TIOCM_CTS : 0) |
256  (test_bit(IFX_SPI_DSR, &ifx_dev->signal_state) ? TIOCM_DSR : 0) |
257  (test_bit(IFX_SPI_DCD, &ifx_dev->signal_state) ? TIOCM_CAR : 0) |
258  (test_bit(IFX_SPI_RI, &ifx_dev->signal_state) ? TIOCM_RNG : 0);
259  return value;
260 }
261 
273 static int ifx_spi_tiocmset(struct tty_struct *tty,
274  unsigned int set, unsigned int clear)
275 {
276  struct ifx_spi_device *ifx_dev = tty->driver_data;
277 
278  if (set & TIOCM_RTS)
279  set_bit(IFX_SPI_RTS, &ifx_dev->signal_state);
280  if (set & TIOCM_DTR)
281  set_bit(IFX_SPI_DTR, &ifx_dev->signal_state);
282  if (clear & TIOCM_RTS)
283  clear_bit(IFX_SPI_RTS, &ifx_dev->signal_state);
284  if (clear & TIOCM_DTR)
285  clear_bit(IFX_SPI_DTR, &ifx_dev->signal_state);
286 
287  set_bit(IFX_SPI_UPDATE, &ifx_dev->signal_state);
288  return 0;
289 }
290 
301 static int ifx_spi_open(struct tty_struct *tty, struct file *filp)
302 {
303  return tty_port_open(&saved_ifx_dev->tty_port, tty, filp);
304 }
305 
314 static void ifx_spi_close(struct tty_struct *tty, struct file *filp)
315 {
316  struct ifx_spi_device *ifx_dev = tty->driver_data;
317  tty_port_close(&ifx_dev->tty_port, tty, filp);
318  /* FIXME: should we do an ifx_spi_reset here ? */
319 }
320 
334 static int ifx_spi_decode_spi_header(unsigned char *buffer, int *length,
335  unsigned char *more, unsigned char *received_cts)
336 {
337  u16 h1;
338  u16 h2;
339  u16 *in_buffer = (u16 *)buffer;
340 
341  h1 = *in_buffer;
342  h2 = *(in_buffer+1);
343 
344  if (h1 == 0 && h2 == 0) {
345  *received_cts = 0;
346  return IFX_SPI_HEADER_0;
347  } else if (h1 == 0xffff && h2 == 0xffff) {
348  /* spi_slave_cts remains as it was */
349  return IFX_SPI_HEADER_F;
350  }
351 
352  *length = h1 & 0xfff; /* upper bits of byte are flags */
353  *more = (buffer[1] >> IFX_SPI_MORE_BIT) & 1;
354  *received_cts = (buffer[3] >> IFX_SPI_CTS_BIT) & 1;
355  return 0;
356 }
357 
368 static void ifx_spi_setup_spi_header(unsigned char *txbuffer, int tx_count,
369  unsigned char more)
370 {
371  *(u16 *)(txbuffer) = tx_count;
372  *(u16 *)(txbuffer+2) = IFX_SPI_PAYLOAD_SIZE;
373  txbuffer[1] |= (more << IFX_SPI_MORE_BIT) & IFX_SPI_MORE_MASK;
374 }
375 
384 static void ifx_spi_wakeup_serial(struct ifx_spi_device *ifx_dev)
385 {
386  struct tty_struct *tty;
387 
388  tty = tty_port_tty_get(&ifx_dev->tty_port);
389  if (!tty)
390  return;
391  tty_wakeup(tty);
392  tty_kref_put(tty);
393 }
394 
407 static int ifx_spi_prepare_tx_buffer(struct ifx_spi_device *ifx_dev)
408 {
409  int temp_count;
410  int queue_length;
411  int tx_count;
412  unsigned char *tx_buffer;
413 
414  tx_buffer = ifx_dev->tx_buffer;
415  memset(tx_buffer, 0, IFX_SPI_TRANSFER_SIZE);
416 
417  /* make room for required SPI header */
418  tx_buffer += IFX_SPI_HEADER_OVERHEAD;
419  tx_count = IFX_SPI_HEADER_OVERHEAD;
420 
421  /* clear to signal no more data if this turns out to be the
422  * last buffer sent in a sequence */
423  ifx_dev->spi_more = 0;
424 
425  /* if modem cts is set, just send empty buffer */
426  if (!ifx_dev->spi_slave_cts) {
427  /* see if there's tx data */
428  queue_length = kfifo_len(&ifx_dev->tx_fifo);
429  if (queue_length != 0) {
430  /* data to mux -- see if there's room for it */
431  temp_count = min(queue_length, IFX_SPI_PAYLOAD_SIZE);
432  temp_count = kfifo_out_locked(&ifx_dev->tx_fifo,
433  tx_buffer, temp_count,
434  &ifx_dev->fifo_lock);
435 
436  /* update buffer pointer and data count in message */
437  tx_buffer += temp_count;
438  tx_count += temp_count;
439  if (temp_count == queue_length)
440  /* poke port to get more data */
441  ifx_spi_wakeup_serial(ifx_dev);
442  else /* more data in port, use next SPI message */
443  ifx_dev->spi_more = 1;
444  }
445  }
446  /* have data and info for header -- set up SPI header in buffer */
447  /* spi header needs payload size, not entire buffer size */
448  ifx_spi_setup_spi_header(ifx_dev->tx_buffer,
449  tx_count-IFX_SPI_HEADER_OVERHEAD,
450  ifx_dev->spi_more);
451  /* swap actual data in the buffer */
452  swap_buf((u16 *)(ifx_dev->tx_buffer), tx_count,
453  &ifx_dev->tx_buffer[IFX_SPI_TRANSFER_SIZE]);
454  return tx_count;
455 }
456 
467 static int ifx_spi_write(struct tty_struct *tty, const unsigned char *buf,
468  int count)
469 {
470  struct ifx_spi_device *ifx_dev = tty->driver_data;
471  unsigned char *tmp_buf = (unsigned char *)buf;
472  int tx_count = kfifo_in_locked(&ifx_dev->tx_fifo, tmp_buf, count,
473  &ifx_dev->fifo_lock);
474  mrdy_assert(ifx_dev);
475  return tx_count;
476 }
477 
485 static int ifx_spi_write_room(struct tty_struct *tty)
486 {
487  struct ifx_spi_device *ifx_dev = tty->driver_data;
488  return IFX_SPI_FIFO_SIZE - kfifo_len(&ifx_dev->tx_fifo);
489 }
490 
498 static int ifx_spi_chars_in_buffer(struct tty_struct *tty)
499 {
500  struct ifx_spi_device *ifx_dev = tty->driver_data;
501  return kfifo_len(&ifx_dev->tx_fifo);
502 }
503 
512 static void ifx_spi_hangup(struct tty_struct *tty)
513 {
514  struct ifx_spi_device *ifx_dev = tty->driver_data;
515  tty_port_hangup(&ifx_dev->tty_port);
516 }
517 
525 static int ifx_port_activate(struct tty_port *port, struct tty_struct *tty)
526 {
527  struct ifx_spi_device *ifx_dev =
528  container_of(port, struct ifx_spi_device, tty_port);
529 
530  /* clear any old data; can't do this in 'close' */
531  kfifo_reset(&ifx_dev->tx_fifo);
532 
533  /* put port data into this tty */
534  tty->driver_data = ifx_dev;
535 
536  /* allows flip string push from int context */
537  tty->low_latency = 1;
538 
539  return 0;
540 }
541 
549 static void ifx_port_shutdown(struct tty_port *port)
550 {
551  struct ifx_spi_device *ifx_dev =
552  container_of(port, struct ifx_spi_device, tty_port);
553 
554  mrdy_set_low(ifx_dev);
556  tasklet_kill(&ifx_dev->io_work_tasklet);
557 }
558 
559 static const struct tty_port_operations ifx_tty_port_ops = {
560  .activate = ifx_port_activate,
561  .shutdown = ifx_port_shutdown,
562 };
563 
564 static const struct tty_operations ifx_spi_serial_ops = {
565  .open = ifx_spi_open,
566  .close = ifx_spi_close,
567  .write = ifx_spi_write,
568  .hangup = ifx_spi_hangup,
569  .write_room = ifx_spi_write_room,
570  .chars_in_buffer = ifx_spi_chars_in_buffer,
571  .tiocmget = ifx_spi_tiocmget,
572  .tiocmset = ifx_spi_tiocmset,
573 };
574 
584 static void ifx_spi_insert_flip_string(struct ifx_spi_device *ifx_dev,
585  unsigned char *chars, size_t size)
586 {
587  struct tty_struct *tty = tty_port_tty_get(&ifx_dev->tty_port);
588  if (!tty)
589  return;
590  tty_insert_flip_string(tty, chars, size);
592  tty_kref_put(tty);
593 }
594 
602 static void ifx_spi_complete(void *ctx)
603 {
604  struct ifx_spi_device *ifx_dev = ctx;
605  struct tty_struct *tty;
606  struct tty_ldisc *ldisc = NULL;
607  int length;
608  int actual_length;
609  unsigned char more;
610  unsigned char cts;
611  int local_write_pending = 0;
612  int queue_length;
613  int srdy;
614  int decode_result;
615 
616  mrdy_set_low(ifx_dev);
617 
618  if (!ifx_dev->spi_msg.status) {
619  /* check header validity, get comm flags */
620  swap_buf((u16 *)ifx_dev->rx_buffer, IFX_SPI_HEADER_OVERHEAD,
622  decode_result = ifx_spi_decode_spi_header(ifx_dev->rx_buffer,
623  &length, &more, &cts);
624  if (decode_result == IFX_SPI_HEADER_0) {
625  dev_dbg(&ifx_dev->spi_dev->dev,
626  "ignore input: invalid header 0");
627  ifx_dev->spi_slave_cts = 0;
628  goto complete_exit;
629  } else if (decode_result == IFX_SPI_HEADER_F) {
630  dev_dbg(&ifx_dev->spi_dev->dev,
631  "ignore input: invalid header F");
632  goto complete_exit;
633  }
634 
635  ifx_dev->spi_slave_cts = cts;
636 
637  actual_length = min((unsigned int)length,
638  ifx_dev->spi_msg.actual_length);
639  swap_buf((u16 *)(ifx_dev->rx_buffer + IFX_SPI_HEADER_OVERHEAD),
640  actual_length,
641  &ifx_dev->rx_buffer[IFX_SPI_TRANSFER_SIZE]);
642  ifx_spi_insert_flip_string(
643  ifx_dev,
645  (size_t)actual_length);
646  } else {
647  dev_dbg(&ifx_dev->spi_dev->dev, "SPI transfer error %d",
648  ifx_dev->spi_msg.status);
649  }
650 
651 complete_exit:
652  if (ifx_dev->write_pending) {
653  ifx_dev->write_pending = 0;
654  local_write_pending = 1;
655  }
656 
658 
659  queue_length = kfifo_len(&ifx_dev->tx_fifo);
660  srdy = gpio_get_value(ifx_dev->gpio.srdy);
661  if (!srdy)
662  ifx_spi_power_state_clear(ifx_dev, IFX_SPI_POWER_SRDY);
663 
664  /* schedule output if there is more to do */
666  tasklet_schedule(&ifx_dev->io_work_tasklet);
667  else {
668  if (more || ifx_dev->spi_more || queue_length > 0 ||
669  local_write_pending) {
670  if (ifx_dev->spi_slave_cts) {
671  if (more)
672  mrdy_assert(ifx_dev);
673  } else
674  mrdy_assert(ifx_dev);
675  } else {
676  /*
677  * poke line discipline driver if any for more data
678  * may or may not get more data to write
679  * for now, say not busy
680  */
681  ifx_spi_power_state_clear(ifx_dev,
683  tty = tty_port_tty_get(&ifx_dev->tty_port);
684  if (tty) {
685  ldisc = tty_ldisc_ref(tty);
686  if (ldisc) {
687  ldisc->ops->write_wakeup(tty);
688  tty_ldisc_deref(ldisc);
689  }
690  tty_kref_put(tty);
691  }
692  }
693  }
694 }
695 
703 static void ifx_spi_io(unsigned long data)
704 {
705  int retval;
706  struct ifx_spi_device *ifx_dev = (struct ifx_spi_device *) data;
707 
709  if (ifx_dev->gpio.unack_srdy_int_nb > 0)
710  ifx_dev->gpio.unack_srdy_int_nb--;
711 
712  ifx_spi_prepare_tx_buffer(ifx_dev);
713 
714  spi_message_init(&ifx_dev->spi_msg);
715  INIT_LIST_HEAD(&ifx_dev->spi_msg.queue);
716 
717  ifx_dev->spi_msg.context = ifx_dev;
718  ifx_dev->spi_msg.complete = ifx_spi_complete;
719 
720  /* set up our spi transfer */
721  /* note len is BYTES, not transfers */
722  ifx_dev->spi_xfer.len = IFX_SPI_TRANSFER_SIZE;
723  ifx_dev->spi_xfer.cs_change = 0;
724  ifx_dev->spi_xfer.speed_hz = ifx_dev->spi_dev->max_speed_hz;
725  /* ifx_dev->spi_xfer.speed_hz = 390625; */
726  ifx_dev->spi_xfer.bits_per_word = spi_bpw;
727 
728  ifx_dev->spi_xfer.tx_buf = ifx_dev->tx_buffer;
729  ifx_dev->spi_xfer.rx_buf = ifx_dev->rx_buffer;
730 
731  /*
732  * setup dma pointers
733  */
734  if (ifx_dev->use_dma) {
735  ifx_dev->spi_msg.is_dma_mapped = 1;
736  ifx_dev->tx_dma = ifx_dev->tx_bus;
737  ifx_dev->rx_dma = ifx_dev->rx_bus;
738  ifx_dev->spi_xfer.tx_dma = ifx_dev->tx_dma;
739  ifx_dev->spi_xfer.rx_dma = ifx_dev->rx_dma;
740  } else {
741  ifx_dev->spi_msg.is_dma_mapped = 0;
742  ifx_dev->tx_dma = (dma_addr_t)0;
743  ifx_dev->rx_dma = (dma_addr_t)0;
744  ifx_dev->spi_xfer.tx_dma = (dma_addr_t)0;
745  ifx_dev->spi_xfer.rx_dma = (dma_addr_t)0;
746  }
747 
748  spi_message_add_tail(&ifx_dev->spi_xfer, &ifx_dev->spi_msg);
749 
750  /* Assert MRDY. This may have already been done by the write
751  * routine.
752  */
753  mrdy_assert(ifx_dev);
754 
755  retval = spi_async(ifx_dev->spi_dev, &ifx_dev->spi_msg);
756  if (retval) {
758  &ifx_dev->flags);
759  tasklet_schedule(&ifx_dev->io_work_tasklet);
760  return;
761  }
762  } else
763  ifx_dev->write_pending = 1;
764 }
765 
772 static void ifx_spi_free_port(struct ifx_spi_device *ifx_dev)
773 {
774  if (ifx_dev->tty_dev)
775  tty_unregister_device(tty_drv, ifx_dev->minor);
776  kfifo_free(&ifx_dev->tx_fifo);
777 }
778 
786 static int ifx_spi_create_port(struct ifx_spi_device *ifx_dev)
787 {
788  int ret = 0;
789  struct tty_port *pport = &ifx_dev->tty_port;
790 
791  spin_lock_init(&ifx_dev->fifo_lock);
793  &ifx_spi_key, 0);
794 
795  if (kfifo_alloc(&ifx_dev->tx_fifo, IFX_SPI_FIFO_SIZE, GFP_KERNEL)) {
796  ret = -ENOMEM;
797  goto error_ret;
798  }
799 
800  tty_port_init(pport);
801  pport->ops = &ifx_tty_port_ops;
802  ifx_dev->minor = IFX_SPI_TTY_ID;
803  ifx_dev->tty_dev = tty_port_register_device(pport, tty_drv,
804  ifx_dev->minor, &ifx_dev->spi_dev->dev);
805  if (IS_ERR(ifx_dev->tty_dev)) {
806  dev_dbg(&ifx_dev->spi_dev->dev,
807  "%s: registering tty device failed", __func__);
808  ret = PTR_ERR(ifx_dev->tty_dev);
809  goto error_ret;
810  }
811  return 0;
812 
813 error_ret:
814  ifx_spi_free_port(ifx_dev);
815  return ret;
816 }
817 
826 static void ifx_spi_handle_srdy(struct ifx_spi_device *ifx_dev)
827 {
828  if (test_bit(IFX_SPI_STATE_TIMER_PENDING, &ifx_dev->flags)) {
829  del_timer_sync(&ifx_dev->spi_timer);
831  }
832 
833  ifx_spi_power_state_set(ifx_dev, IFX_SPI_POWER_SRDY);
834 
836  tasklet_schedule(&ifx_dev->io_work_tasklet);
837  else
839 }
840 
848 static irqreturn_t ifx_spi_srdy_interrupt(int irq, void *dev)
849 {
850  struct ifx_spi_device *ifx_dev = dev;
851  ifx_dev->gpio.unack_srdy_int_nb++;
852  ifx_spi_handle_srdy(ifx_dev);
853  return IRQ_HANDLED;
854 }
855 
867 static irqreturn_t ifx_spi_reset_interrupt(int irq, void *dev)
868 {
869  struct ifx_spi_device *ifx_dev = dev;
870  int val = gpio_get_value(ifx_dev->gpio.reset_out);
871  int solreset = test_bit(MR_START, &ifx_dev->mdm_reset_state);
872 
873  if (val == 0) {
874  /* entered reset */
876  if (!solreset) {
877  /* unsolicited reset */
878  ifx_spi_ttyhangup(ifx_dev);
879  }
880  } else {
881  /* exited reset */
883  if (solreset) {
884  set_bit(MR_COMPLETE, &ifx_dev->mdm_reset_state);
885  wake_up(&ifx_dev->mdm_reset_wait);
886  }
887  }
888  return IRQ_HANDLED;
889 }
890 
897 static void ifx_spi_free_device(struct ifx_spi_device *ifx_dev)
898 {
899  ifx_spi_free_port(ifx_dev);
900  dma_free_coherent(&ifx_dev->spi_dev->dev,
902  ifx_dev->tx_buffer,
903  ifx_dev->tx_bus);
904  dma_free_coherent(&ifx_dev->spi_dev->dev,
906  ifx_dev->rx_buffer,
907  ifx_dev->rx_bus);
908 }
909 
916 static int ifx_spi_reset(struct ifx_spi_device *ifx_dev)
917 {
918  int ret;
919  /*
920  * set up modem power, reset
921  *
922  * delays are required on some platforms for the modem
923  * to reset properly
924  */
925  set_bit(MR_START, &ifx_dev->mdm_reset_state);
926  gpio_set_value(ifx_dev->gpio.po, 0);
927  gpio_set_value(ifx_dev->gpio.reset, 0);
928  msleep(25);
929  gpio_set_value(ifx_dev->gpio.reset, 1);
930  msleep(1);
931  gpio_set_value(ifx_dev->gpio.po, 1);
932  msleep(1);
933  gpio_set_value(ifx_dev->gpio.po, 0);
934  ret = wait_event_timeout(ifx_dev->mdm_reset_wait,
936  &ifx_dev->mdm_reset_state),
938  if (!ret)
939  dev_warn(&ifx_dev->spi_dev->dev, "Modem reset timeout: (state:%lx)",
940  ifx_dev->mdm_reset_state);
941 
942  ifx_dev->mdm_reset_state = 0;
943  return ret;
944 }
945 
958 static int ifx_spi_spi_probe(struct spi_device *spi)
959 {
960  int ret;
961  int srdy;
962  struct ifx_modem_platform_data *pl_data;
963  struct ifx_spi_device *ifx_dev;
964 
965  if (saved_ifx_dev) {
966  dev_dbg(&spi->dev, "ignoring subsequent detection");
967  return -ENODEV;
968  }
969 
970  pl_data = (struct ifx_modem_platform_data *)spi->dev.platform_data;
971  if (!pl_data) {
972  dev_err(&spi->dev, "missing platform data!");
973  return -ENODEV;
974  }
975 
976  /* initialize structure to hold our device variables */
977  ifx_dev = kzalloc(sizeof(struct ifx_spi_device), GFP_KERNEL);
978  if (!ifx_dev) {
979  dev_err(&spi->dev, "spi device allocation failed");
980  return -ENOMEM;
981  }
982  saved_ifx_dev = ifx_dev;
983  ifx_dev->spi_dev = spi;
985  spin_lock_init(&ifx_dev->write_lock);
986  spin_lock_init(&ifx_dev->power_lock);
987  ifx_dev->power_status = 0;
988  init_timer(&ifx_dev->spi_timer);
989  ifx_dev->spi_timer.function = ifx_spi_timeout;
990  ifx_dev->spi_timer.data = (unsigned long)ifx_dev;
991  ifx_dev->modem = pl_data->modem_type;
992  ifx_dev->use_dma = pl_data->use_dma;
993  ifx_dev->max_hz = pl_data->max_hz;
994  /* initialize spi mode, etc */
995  spi->max_speed_hz = ifx_dev->max_hz;
996  spi->mode = IFX_SPI_MODE | (SPI_LOOP & spi->mode);
997  spi->bits_per_word = spi_bpw;
998  ret = spi_setup(spi);
999  if (ret) {
1000  dev_err(&spi->dev, "SPI setup wasn't successful %d", ret);
1001  return -ENODEV;
1002  }
1003 
1004  /* ensure SPI protocol flags are initialized to enable transfer */
1005  ifx_dev->spi_more = 0;
1006  ifx_dev->spi_slave_cts = 0;
1007 
1008  /*initialize transfer and dma buffers */
1009  ifx_dev->tx_buffer = dma_alloc_coherent(ifx_dev->spi_dev->dev.parent,
1011  &ifx_dev->tx_bus,
1012  GFP_KERNEL);
1013  if (!ifx_dev->tx_buffer) {
1014  dev_err(&spi->dev, "DMA-TX buffer allocation failed");
1015  ret = -ENOMEM;
1016  goto error_ret;
1017  }
1018  ifx_dev->rx_buffer = dma_alloc_coherent(ifx_dev->spi_dev->dev.parent,
1020  &ifx_dev->rx_bus,
1021  GFP_KERNEL);
1022  if (!ifx_dev->rx_buffer) {
1023  dev_err(&spi->dev, "DMA-RX buffer allocation failed");
1024  ret = -ENOMEM;
1025  goto error_ret;
1026  }
1027 
1028  /* initialize waitq for modem reset */
1030 
1031  spi_set_drvdata(spi, ifx_dev);
1032  tasklet_init(&ifx_dev->io_work_tasklet, ifx_spi_io,
1033  (unsigned long)ifx_dev);
1034 
1035  set_bit(IFX_SPI_STATE_PRESENT, &ifx_dev->flags);
1036 
1037  /* create our tty port */
1038  ret = ifx_spi_create_port(ifx_dev);
1039  if (ret != 0) {
1040  dev_err(&spi->dev, "create default tty port failed");
1041  goto error_ret;
1042  }
1043 
1044  ifx_dev->gpio.reset = pl_data->rst_pmu;
1045  ifx_dev->gpio.po = pl_data->pwr_on;
1046  ifx_dev->gpio.mrdy = pl_data->mrdy;
1047  ifx_dev->gpio.srdy = pl_data->srdy;
1048  ifx_dev->gpio.reset_out = pl_data->rst_out;
1049 
1050  dev_info(&spi->dev, "gpios %d, %d, %d, %d, %d",
1051  ifx_dev->gpio.reset, ifx_dev->gpio.po, ifx_dev->gpio.mrdy,
1052  ifx_dev->gpio.srdy, ifx_dev->gpio.reset_out);
1053 
1054  /* Configure gpios */
1055  ret = gpio_request(ifx_dev->gpio.reset, "ifxModem");
1056  if (ret < 0) {
1057  dev_err(&spi->dev, "Unable to allocate GPIO%d (RESET)",
1058  ifx_dev->gpio.reset);
1059  goto error_ret;
1060  }
1061  ret += gpio_direction_output(ifx_dev->gpio.reset, 0);
1062  ret += gpio_export(ifx_dev->gpio.reset, 1);
1063  if (ret) {
1064  dev_err(&spi->dev, "Unable to configure GPIO%d (RESET)",
1065  ifx_dev->gpio.reset);
1066  ret = -EBUSY;
1067  goto error_ret2;
1068  }
1069 
1070  ret = gpio_request(ifx_dev->gpio.po, "ifxModem");
1071  ret += gpio_direction_output(ifx_dev->gpio.po, 0);
1072  ret += gpio_export(ifx_dev->gpio.po, 1);
1073  if (ret) {
1074  dev_err(&spi->dev, "Unable to configure GPIO%d (ON)",
1075  ifx_dev->gpio.po);
1076  ret = -EBUSY;
1077  goto error_ret3;
1078  }
1079 
1080  ret = gpio_request(ifx_dev->gpio.mrdy, "ifxModem");
1081  if (ret < 0) {
1082  dev_err(&spi->dev, "Unable to allocate GPIO%d (MRDY)",
1083  ifx_dev->gpio.mrdy);
1084  goto error_ret3;
1085  }
1086  ret += gpio_export(ifx_dev->gpio.mrdy, 1);
1087  ret += gpio_direction_output(ifx_dev->gpio.mrdy, 0);
1088  if (ret) {
1089  dev_err(&spi->dev, "Unable to configure GPIO%d (MRDY)",
1090  ifx_dev->gpio.mrdy);
1091  ret = -EBUSY;
1092  goto error_ret4;
1093  }
1094 
1095  ret = gpio_request(ifx_dev->gpio.srdy, "ifxModem");
1096  if (ret < 0) {
1097  dev_err(&spi->dev, "Unable to allocate GPIO%d (SRDY)",
1098  ifx_dev->gpio.srdy);
1099  ret = -EBUSY;
1100  goto error_ret4;
1101  }
1102  ret += gpio_export(ifx_dev->gpio.srdy, 1);
1103  ret += gpio_direction_input(ifx_dev->gpio.srdy);
1104  if (ret) {
1105  dev_err(&spi->dev, "Unable to configure GPIO%d (SRDY)",
1106  ifx_dev->gpio.srdy);
1107  ret = -EBUSY;
1108  goto error_ret5;
1109  }
1110 
1111  ret = gpio_request(ifx_dev->gpio.reset_out, "ifxModem");
1112  if (ret < 0) {
1113  dev_err(&spi->dev, "Unable to allocate GPIO%d (RESET_OUT)",
1114  ifx_dev->gpio.reset_out);
1115  goto error_ret5;
1116  }
1117  ret += gpio_export(ifx_dev->gpio.reset_out, 1);
1118  ret += gpio_direction_input(ifx_dev->gpio.reset_out);
1119  if (ret) {
1120  dev_err(&spi->dev, "Unable to configure GPIO%d (RESET_OUT)",
1121  ifx_dev->gpio.reset_out);
1122  ret = -EBUSY;
1123  goto error_ret6;
1124  }
1125 
1126  ret = request_irq(gpio_to_irq(ifx_dev->gpio.reset_out),
1127  ifx_spi_reset_interrupt,
1129  (void *)ifx_dev);
1130  if (ret) {
1131  dev_err(&spi->dev, "Unable to get irq %x\n",
1132  gpio_to_irq(ifx_dev->gpio.reset_out));
1133  goto error_ret6;
1134  }
1135 
1136  ret = ifx_spi_reset(ifx_dev);
1137 
1138  ret = request_irq(gpio_to_irq(ifx_dev->gpio.srdy),
1139  ifx_spi_srdy_interrupt,
1141  (void *)ifx_dev);
1142  if (ret) {
1143  dev_err(&spi->dev, "Unable to get irq %x",
1144  gpio_to_irq(ifx_dev->gpio.srdy));
1145  goto error_ret7;
1146  }
1147 
1148  /* set pm runtime power state and register with power system */
1149  pm_runtime_set_active(&spi->dev);
1150  pm_runtime_enable(&spi->dev);
1151 
1152  /* handle case that modem is already signaling SRDY */
1153  /* no outgoing tty open at this point, this just satisfies the
1154  * modem's read and should reset communication properly
1155  */
1156  srdy = gpio_get_value(ifx_dev->gpio.srdy);
1157 
1158  if (srdy) {
1159  mrdy_assert(ifx_dev);
1160  ifx_spi_handle_srdy(ifx_dev);
1161  } else
1162  mrdy_set_low(ifx_dev);
1163  return 0;
1164 
1165 error_ret7:
1166  free_irq(gpio_to_irq(ifx_dev->gpio.reset_out), (void *)ifx_dev);
1167 error_ret6:
1168  gpio_free(ifx_dev->gpio.srdy);
1169 error_ret5:
1170  gpio_free(ifx_dev->gpio.mrdy);
1171 error_ret4:
1172  gpio_free(ifx_dev->gpio.reset);
1173 error_ret3:
1174  gpio_free(ifx_dev->gpio.po);
1175 error_ret2:
1176  gpio_free(ifx_dev->gpio.reset_out);
1177 error_ret:
1178  ifx_spi_free_device(ifx_dev);
1179  saved_ifx_dev = NULL;
1180  return ret;
1181 }
1182 
1191 static int ifx_spi_spi_remove(struct spi_device *spi)
1192 {
1193  struct ifx_spi_device *ifx_dev = spi_get_drvdata(spi);
1194  /* stop activity */
1195  tasklet_kill(&ifx_dev->io_work_tasklet);
1196  /* free irq */
1197  free_irq(gpio_to_irq(ifx_dev->gpio.reset_out), (void *)ifx_dev);
1198  free_irq(gpio_to_irq(ifx_dev->gpio.srdy), (void *)ifx_dev);
1199 
1200  gpio_free(ifx_dev->gpio.srdy);
1201  gpio_free(ifx_dev->gpio.mrdy);
1202  gpio_free(ifx_dev->gpio.reset);
1203  gpio_free(ifx_dev->gpio.po);
1204  gpio_free(ifx_dev->gpio.reset_out);
1205 
1206  /* free allocations */
1207  ifx_spi_free_device(ifx_dev);
1208 
1209  saved_ifx_dev = NULL;
1210  return 0;
1211 }
1212 
1220 static void ifx_spi_spi_shutdown(struct spi_device *spi)
1221 {
1222 }
1223 
1224 /*
1225  * various suspends and resumes have nothing to do
1226  * no hardware to save state for
1227  */
1228 
1236 static int ifx_spi_spi_suspend(struct spi_device *spi, pm_message_t msg)
1237 {
1238  return 0;
1239 }
1240 
1248 static int ifx_spi_spi_resume(struct spi_device *spi)
1249 {
1250  return 0;
1251 }
1252 
1260 static int ifx_spi_pm_suspend(struct device *dev)
1261 {
1262  return 0;
1263 }
1264 
1273 static int ifx_spi_pm_resume(struct device *dev)
1274 {
1275  return 0;
1276 }
1277 
1284 static int ifx_spi_pm_runtime_resume(struct device *dev)
1285 {
1286  return 0;
1287 }
1288 
1296 static int ifx_spi_pm_runtime_suspend(struct device *dev)
1297 {
1298  return 0;
1299 }
1300 
1307 static int ifx_spi_pm_runtime_idle(struct device *dev)
1308 {
1309  struct spi_device *spi = to_spi_device(dev);
1310  struct ifx_spi_device *ifx_dev = spi_get_drvdata(spi);
1311 
1312  if (!ifx_dev->power_status)
1313  pm_runtime_suspend(dev);
1314 
1315  return 0;
1316 }
1317 
1318 static const struct dev_pm_ops ifx_spi_pm = {
1319  .resume = ifx_spi_pm_resume,
1320  .suspend = ifx_spi_pm_suspend,
1321  .runtime_resume = ifx_spi_pm_runtime_resume,
1322  .runtime_suspend = ifx_spi_pm_runtime_suspend,
1323  .runtime_idle = ifx_spi_pm_runtime_idle
1324 };
1325 
1326 static const struct spi_device_id ifx_id_table[] = {
1327  {"ifx6160", 0},
1328  {"ifx6260", 0},
1329  { }
1330 };
1331 MODULE_DEVICE_TABLE(spi, ifx_id_table);
1332 
1333 /* spi operations */
1334 static struct spi_driver ifx_spi_driver = {
1335  .driver = {
1336  .name = DRVNAME,
1337  .pm = &ifx_spi_pm,
1338  .owner = THIS_MODULE},
1339  .probe = ifx_spi_spi_probe,
1340  .shutdown = ifx_spi_spi_shutdown,
1341  .remove = __devexit_p(ifx_spi_spi_remove),
1342  .suspend = ifx_spi_spi_suspend,
1343  .resume = ifx_spi_spi_resume,
1344  .id_table = ifx_id_table
1345 };
1346 
1353 static void __exit ifx_spi_exit(void)
1354 {
1355  /* unregister */
1356  tty_unregister_driver(tty_drv);
1357  spi_unregister_driver((void *)&ifx_spi_driver);
1358 }
1359 
1368 static int __init ifx_spi_init(void)
1369 {
1370  int result;
1371 
1372  tty_drv = alloc_tty_driver(1);
1373  if (!tty_drv) {
1374  pr_err("%s: alloc_tty_driver failed", DRVNAME);
1375  return -ENOMEM;
1376  }
1377 
1378  tty_drv->driver_name = DRVNAME;
1379  tty_drv->name = TTYNAME;
1380  tty_drv->minor_start = IFX_SPI_TTY_ID;
1381  tty_drv->type = TTY_DRIVER_TYPE_SERIAL;
1382  tty_drv->subtype = SERIAL_TYPE_NORMAL;
1384  tty_drv->init_termios = tty_std_termios;
1385 
1386  tty_set_operations(tty_drv, &ifx_spi_serial_ops);
1387 
1388  result = tty_register_driver(tty_drv);
1389  if (result) {
1390  pr_err("%s: tty_register_driver failed(%d)",
1391  DRVNAME, result);
1392  put_tty_driver(tty_drv);
1393  return result;
1394  }
1395 
1396  result = spi_register_driver((void *)&ifx_spi_driver);
1397  if (result) {
1398  pr_err("%s: spi_register_driver failed(%d)",
1399  DRVNAME, result);
1400  tty_unregister_driver(tty_drv);
1401  }
1402  return result;
1403 }
1404 
1405 module_init(ifx_spi_init);
1406 module_exit(ifx_spi_exit);
1407 
1408 MODULE_AUTHOR("Intel");
1409 MODULE_DESCRIPTION("IFX6x60 spi driver");
1410 MODULE_LICENSE("GPL");
1411 MODULE_INFO(Version, "0.1-IFX6x60");