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 79 struct 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 115 static inline struct max3100_port *to_max3100_port(struct uart_port *port) 116 { 117 return container_of(port, struct max3100_port, port); 118 } 119 120 static struct max3100_port *max3100s[MAX_MAX3100]; /* the chips */ 121 static DEFINE_MUTEX(max3100s_lock); /* race on probe */ 122 123 static 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 141 static int max3100_check_parity(struct max3100_port *s, u16 c) 142 { 143 return max3100_do_parity(s, c) == ((c >> 8) & 1); 144 } 145 146 static 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 157 static 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 182 static 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 223 static 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 234 static 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 304 static 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 310 static 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 318 static 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 328 static 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 336 static 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 345 static 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 359 static 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 370 static 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 382 static 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 406 static void 407 max3100_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 524 static 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 549 static 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 595 static 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 604 static 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 611 static 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 621 static 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 634 static 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 641 static 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 649 static 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 656 static 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 675 static 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 }; 683 static int uart_driver_registered; 684 685 static 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, -ENOMEM, "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 744 static 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 776 static 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 793 static 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 811 static DEFINE_SIMPLE_DEV_PM_OPS(max3100_pm_ops, max3100_suspend, max3100_resume); 812 813 static const struct spi_device_id max3100_spi_id[] = { 814 { "max3100" }, 815 { } 816 }; 817 MODULE_DEVICE_TABLE(spi, max3100_spi_id); 818 819 static const struct of_device_id max3100_of_match[] = { 820 { .compatible = "maxim,max3100" }, 821 { } 822 }; 823 MODULE_DEVICE_TABLE(of, max3100_of_match); 824 825 static 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 836 module_spi_driver(max3100_driver); 837 838 MODULE_DESCRIPTION("MAX3100 driver"); 839 MODULE_AUTHOR("Christian Pellegrin <chripell@evolware.org>"); 840 MODULE_LICENSE("GPL"); 841