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