linux/drivers/tty/serial/max3100.c
<<
>>
Prefs
   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
  97struct 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
 141static struct max3100_port *max3100s[MAX_MAX3100]; /* the chips */
 142static DEFINE_MUTEX(max3100s_lock);                /* race on probe */
 143
 144static 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
 162static int max3100_check_parity(struct max3100_port *s, u16 c)
 163{
 164        return max3100_do_parity(s, c) == ((c >> 8) & 1);
 165}
 166
 167static 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
 178static void max3100_work(struct work_struct *w);
 179
 180static 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
 186static 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
 196static 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
 221static 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
 261static 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
 330static 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
 340static 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
 351static 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
 362static 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
 378static 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
 391static 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
 405static 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
 425static void
 426max3100_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
 550static 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
 585static 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
 640static 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
 651static 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
 660static 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
 672static 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
 687static 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
 696static 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
 706static 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
 715static const 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
 734static 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};
 742static int uart_driver_registered;
 743
 744static 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 = msecs_to_jiffies(pdata->poll_time);
 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
 820static 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
 854static 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
 877static 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
 897static 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
 904static struct spi_driver max3100_driver = {
 905        .driver = {
 906                .name           = "max3100",
 907                .pm             = MAX3100_PM_OPS,
 908        },
 909        .probe          = max3100_probe,
 910        .remove         = max3100_remove,
 911};
 912
 913module_spi_driver(max3100_driver);
 914
 915MODULE_DESCRIPTION("MAX3100 driver");
 916MODULE_AUTHOR("Christian Pellegrin <chripell@evolware.org>");
 917MODULE_LICENSE("GPL");
 918MODULE_ALIAS("spi:max3100");
 919