max3100.c

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