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