linux/drivers/net/caif/caif_spi.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) ST-Ericsson AB 2010
   3 * Author:  Daniel Martensson
   4 * License terms: GNU General Public License (GPL) version 2.
   5 */
   6
   7#include <linux/init.h>
   8#include <linux/module.h>
   9#include <linux/device.h>
  10#include <linux/platform_device.h>
  11#include <linux/string.h>
  12#include <linux/workqueue.h>
  13#include <linux/completion.h>
  14#include <linux/list.h>
  15#include <linux/interrupt.h>
  16#include <linux/dma-mapping.h>
  17#include <linux/delay.h>
  18#include <linux/sched.h>
  19#include <linux/debugfs.h>
  20#include <linux/if_arp.h>
  21#include <net/caif/caif_layer.h>
  22#include <net/caif/caif_spi.h>
  23
  24#ifndef CONFIG_CAIF_SPI_SYNC
  25#define FLAVOR "Flavour: Vanilla.\n"
  26#else
  27#define FLAVOR "Flavour: Master CMD&LEN at start.\n"
  28#endif /* CONFIG_CAIF_SPI_SYNC */
  29
  30MODULE_LICENSE("GPL");
  31MODULE_AUTHOR("Daniel Martensson");
  32MODULE_DESCRIPTION("CAIF SPI driver");
  33
  34/* Returns the number of padding bytes for alignment. */
  35#define PAD_POW2(x, pow) ((((x)&((pow)-1))==0) ? 0 : (((pow)-((x)&((pow)-1)))))
  36
  37static bool spi_loop;
  38module_param(spi_loop, bool, S_IRUGO);
  39MODULE_PARM_DESC(spi_loop, "SPI running in loopback mode.");
  40
  41/* SPI frame alignment. */
  42module_param(spi_frm_align, int, S_IRUGO);
  43MODULE_PARM_DESC(spi_frm_align, "SPI frame alignment.");
  44
  45/*
  46 * SPI padding options.
  47 * Warning: must be a base of 2 (& operation used) and can not be zero !
  48 */
  49module_param(spi_up_head_align, int, S_IRUGO);
  50MODULE_PARM_DESC(spi_up_head_align, "SPI uplink head alignment.");
  51
  52module_param(spi_up_tail_align, int, S_IRUGO);
  53MODULE_PARM_DESC(spi_up_tail_align, "SPI uplink tail alignment.");
  54
  55module_param(spi_down_head_align, int, S_IRUGO);
  56MODULE_PARM_DESC(spi_down_head_align, "SPI downlink head alignment.");
  57
  58module_param(spi_down_tail_align, int, S_IRUGO);
  59MODULE_PARM_DESC(spi_down_tail_align, "SPI downlink tail alignment.");
  60
  61#ifdef CONFIG_ARM
  62#define BYTE_HEX_FMT "%02X"
  63#else
  64#define BYTE_HEX_FMT "%02hhX"
  65#endif
  66
  67#define SPI_MAX_PAYLOAD_SIZE 4096
  68/*
  69 * Threshold values for the SPI packet queue. Flowcontrol will be asserted
  70 * when the number of packets exceeds HIGH_WATER_MARK. It will not be
  71 * deasserted before the number of packets drops below LOW_WATER_MARK.
  72 */
  73#define LOW_WATER_MARK   100
  74#define HIGH_WATER_MARK  (LOW_WATER_MARK*5)
  75
  76#ifdef CONFIG_UML
  77
  78/*
  79 * We sometimes use UML for debugging, but it cannot handle
  80 * dma_alloc_coherent so we have to wrap it.
  81 */
  82static inline void *dma_alloc(dma_addr_t *daddr)
  83{
  84        return kmalloc(SPI_DMA_BUF_LEN, GFP_KERNEL);
  85}
  86
  87static inline void dma_free(void *cpu_addr, dma_addr_t handle)
  88{
  89        kfree(cpu_addr);
  90}
  91
  92#else
  93
  94static inline void *dma_alloc(dma_addr_t *daddr)
  95{
  96        return dma_alloc_coherent(NULL, SPI_DMA_BUF_LEN, daddr,
  97                                GFP_KERNEL);
  98}
  99
 100static inline void dma_free(void *cpu_addr, dma_addr_t handle)
 101{
 102        dma_free_coherent(NULL, SPI_DMA_BUF_LEN, cpu_addr, handle);
 103}
 104#endif  /* CONFIG_UML */
 105
 106#ifdef CONFIG_DEBUG_FS
 107
 108#define DEBUGFS_BUF_SIZE        4096
 109
 110static struct dentry *dbgfs_root;
 111
 112static inline void driver_debugfs_create(void)
 113{
 114        dbgfs_root = debugfs_create_dir(cfspi_spi_driver.driver.name, NULL);
 115}
 116
 117static inline void driver_debugfs_remove(void)
 118{
 119        debugfs_remove(dbgfs_root);
 120}
 121
 122static inline void dev_debugfs_rem(struct cfspi *cfspi)
 123{
 124        debugfs_remove(cfspi->dbgfs_frame);
 125        debugfs_remove(cfspi->dbgfs_state);
 126        debugfs_remove(cfspi->dbgfs_dir);
 127}
 128
 129static ssize_t dbgfs_state(struct file *file, char __user *user_buf,
 130                           size_t count, loff_t *ppos)
 131{
 132        char *buf;
 133        int len = 0;
 134        ssize_t size;
 135        struct cfspi *cfspi = file->private_data;
 136
 137        buf = kzalloc(DEBUGFS_BUF_SIZE, GFP_KERNEL);
 138        if (!buf)
 139                return 0;
 140
 141        /* Print out debug information. */
 142        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 143                        "CAIF SPI debug information:\n");
 144
 145        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len), FLAVOR);
 146
 147        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 148                        "STATE: %d\n", cfspi->dbg_state);
 149        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 150                        "Previous CMD: 0x%x\n", cfspi->pcmd);
 151        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 152                        "Current CMD: 0x%x\n", cfspi->cmd);
 153        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 154                        "Previous TX len: %d\n", cfspi->tx_ppck_len);
 155        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 156                        "Previous RX len: %d\n", cfspi->rx_ppck_len);
 157        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 158                        "Current TX len: %d\n", cfspi->tx_cpck_len);
 159        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 160                        "Current RX len: %d\n", cfspi->rx_cpck_len);
 161        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 162                        "Next TX len: %d\n", cfspi->tx_npck_len);
 163        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 164                        "Next RX len: %d\n", cfspi->rx_npck_len);
 165
 166        if (len > DEBUGFS_BUF_SIZE)
 167                len = DEBUGFS_BUF_SIZE;
 168
 169        size = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 170        kfree(buf);
 171
 172        return size;
 173}
 174
 175static ssize_t print_frame(char *buf, size_t size, char *frm,
 176                           size_t count, size_t cut)
 177{
 178        int len = 0;
 179        int i;
 180        for (i = 0; i < count; i++) {
 181                len += snprintf((buf + len), (size - len),
 182                                        "[0x" BYTE_HEX_FMT "]",
 183                                        frm[i]);
 184                if ((i == cut) && (count > (cut * 2))) {
 185                        /* Fast forward. */
 186                        i = count - cut;
 187                        len += snprintf((buf + len), (size - len),
 188                                        "--- %u bytes skipped ---\n",
 189                                        (int)(count - (cut * 2)));
 190                }
 191
 192                if ((!(i % 10)) && i) {
 193                        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 194                                        "\n");
 195                }
 196        }
 197        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len), "\n");
 198        return len;
 199}
 200
 201static ssize_t dbgfs_frame(struct file *file, char __user *user_buf,
 202                           size_t count, loff_t *ppos)
 203{
 204        char *buf;
 205        int len = 0;
 206        ssize_t size;
 207        struct cfspi *cfspi;
 208
 209        cfspi = file->private_data;
 210        buf = kzalloc(DEBUGFS_BUF_SIZE, GFP_KERNEL);
 211        if (!buf)
 212                return 0;
 213
 214        /* Print out debug information. */
 215        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 216                        "Current frame:\n");
 217
 218        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 219                        "Tx data (Len: %d):\n", cfspi->tx_cpck_len);
 220
 221        len += print_frame((buf + len), (DEBUGFS_BUF_SIZE - len),
 222                           cfspi->xfer.va_tx[0],
 223                           (cfspi->tx_cpck_len + SPI_CMD_SZ), 100);
 224
 225        len += snprintf((buf + len), (DEBUGFS_BUF_SIZE - len),
 226                        "Rx data (Len: %d):\n", cfspi->rx_cpck_len);
 227
 228        len += print_frame((buf + len), (DEBUGFS_BUF_SIZE - len),
 229                           cfspi->xfer.va_rx,
 230                           (cfspi->rx_cpck_len + SPI_CMD_SZ), 100);
 231
 232        size = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 233        kfree(buf);
 234
 235        return size;
 236}
 237
 238static const struct file_operations dbgfs_state_fops = {
 239        .open = simple_open,
 240        .read = dbgfs_state,
 241        .owner = THIS_MODULE
 242};
 243
 244static const struct file_operations dbgfs_frame_fops = {
 245        .open = simple_open,
 246        .read = dbgfs_frame,
 247        .owner = THIS_MODULE
 248};
 249
 250static inline void dev_debugfs_add(struct cfspi *cfspi)
 251{
 252        cfspi->dbgfs_dir = debugfs_create_dir(cfspi->pdev->name, dbgfs_root);
 253        cfspi->dbgfs_state = debugfs_create_file("state", S_IRUGO,
 254                                                 cfspi->dbgfs_dir, cfspi,
 255                                                 &dbgfs_state_fops);
 256        cfspi->dbgfs_frame = debugfs_create_file("frame", S_IRUGO,
 257                                                 cfspi->dbgfs_dir, cfspi,
 258                                                 &dbgfs_frame_fops);
 259}
 260
 261inline void cfspi_dbg_state(struct cfspi *cfspi, int state)
 262{
 263        cfspi->dbg_state = state;
 264};
 265#else
 266
 267static inline void driver_debugfs_create(void)
 268{
 269}
 270
 271static inline void driver_debugfs_remove(void)
 272{
 273}
 274
 275static inline void dev_debugfs_add(struct cfspi *cfspi)
 276{
 277}
 278
 279static inline void dev_debugfs_rem(struct cfspi *cfspi)
 280{
 281}
 282
 283inline void cfspi_dbg_state(struct cfspi *cfspi, int state)
 284{
 285}
 286#endif                          /* CONFIG_DEBUG_FS */
 287
 288static LIST_HEAD(cfspi_list);
 289static spinlock_t cfspi_list_lock;
 290
 291/* SPI uplink head alignment. */
 292static ssize_t show_up_head_align(struct device_driver *driver, char *buf)
 293{
 294        return sprintf(buf, "%d\n", spi_up_head_align);
 295}
 296
 297static DRIVER_ATTR(up_head_align, S_IRUSR, show_up_head_align, NULL);
 298
 299/* SPI uplink tail alignment. */
 300static ssize_t show_up_tail_align(struct device_driver *driver, char *buf)
 301{
 302        return sprintf(buf, "%d\n", spi_up_tail_align);
 303}
 304
 305static DRIVER_ATTR(up_tail_align, S_IRUSR, show_up_tail_align, NULL);
 306
 307/* SPI downlink head alignment. */
 308static ssize_t show_down_head_align(struct device_driver *driver, char *buf)
 309{
 310        return sprintf(buf, "%d\n", spi_down_head_align);
 311}
 312
 313static DRIVER_ATTR(down_head_align, S_IRUSR, show_down_head_align, NULL);
 314
 315/* SPI downlink tail alignment. */
 316static ssize_t show_down_tail_align(struct device_driver *driver, char *buf)
 317{
 318        return sprintf(buf, "%d\n", spi_down_tail_align);
 319}
 320
 321static DRIVER_ATTR(down_tail_align, S_IRUSR, show_down_tail_align, NULL);
 322
 323/* SPI frame alignment. */
 324static ssize_t show_frame_align(struct device_driver *driver, char *buf)
 325{
 326        return sprintf(buf, "%d\n", spi_frm_align);
 327}
 328
 329static DRIVER_ATTR(frame_align, S_IRUSR, show_frame_align, NULL);
 330
 331int cfspi_xmitfrm(struct cfspi *cfspi, u8 *buf, size_t len)
 332{
 333        u8 *dst = buf;
 334        caif_assert(buf);
 335
 336        if (cfspi->slave && !cfspi->slave_talked)
 337                cfspi->slave_talked = true;
 338
 339        do {
 340                struct sk_buff *skb;
 341                struct caif_payload_info *info;
 342                int spad = 0;
 343                int epad;
 344
 345                skb = skb_dequeue(&cfspi->chead);
 346                if (!skb)
 347                        break;
 348
 349                /*
 350                 * Calculate length of frame including SPI padding.
 351                 * The payload position is found in the control buffer.
 352                 */
 353                info = (struct caif_payload_info *)&skb->cb;
 354
 355                /*
 356                 * Compute head offset i.e. number of bytes to add to
 357                 * get the start of the payload aligned.
 358                 */
 359                if (spi_up_head_align > 1) {
 360                        spad = 1 + PAD_POW2((info->hdr_len + 1), spi_up_head_align);
 361                        *dst = (u8)(spad - 1);
 362                        dst += spad;
 363                }
 364
 365                /* Copy in CAIF frame. */
 366                skb_copy_bits(skb, 0, dst, skb->len);
 367                dst += skb->len;
 368                cfspi->ndev->stats.tx_packets++;
 369                cfspi->ndev->stats.tx_bytes += skb->len;
 370
 371                /*
 372                 * Compute tail offset i.e. number of bytes to add to
 373                 * get the complete CAIF frame aligned.
 374                 */
 375                epad = PAD_POW2((skb->len + spad), spi_up_tail_align);
 376                dst += epad;
 377
 378                dev_kfree_skb(skb);
 379
 380        } while ((dst - buf) < len);
 381
 382        return dst - buf;
 383}
 384
 385int cfspi_xmitlen(struct cfspi *cfspi)
 386{
 387        struct sk_buff *skb = NULL;
 388        int frm_len = 0;
 389        int pkts = 0;
 390
 391        /*
 392         * Decommit previously committed frames.
 393         * skb_queue_splice_tail(&cfspi->chead,&cfspi->qhead)
 394         */
 395        while (skb_peek(&cfspi->chead)) {
 396                skb = skb_dequeue_tail(&cfspi->chead);
 397                skb_queue_head(&cfspi->qhead, skb);
 398        }
 399
 400        do {
 401                struct caif_payload_info *info = NULL;
 402                int spad = 0;
 403                int epad = 0;
 404
 405                skb = skb_dequeue(&cfspi->qhead);
 406                if (!skb)
 407                        break;
 408
 409                /*
 410                 * Calculate length of frame including SPI padding.
 411                 * The payload position is found in the control buffer.
 412                 */
 413                info = (struct caif_payload_info *)&skb->cb;
 414
 415                /*
 416                 * Compute head offset i.e. number of bytes to add to
 417                 * get the start of the payload aligned.
 418                 */
 419                if (spi_up_head_align > 1)
 420                        spad = 1 + PAD_POW2((info->hdr_len + 1), spi_up_head_align);
 421
 422                /*
 423                 * Compute tail offset i.e. number of bytes to add to
 424                 * get the complete CAIF frame aligned.
 425                 */
 426                epad = PAD_POW2((skb->len + spad), spi_up_tail_align);
 427
 428                if ((skb->len + spad + epad + frm_len) <= CAIF_MAX_SPI_FRAME) {
 429                        skb_queue_tail(&cfspi->chead, skb);
 430                        pkts++;
 431                        frm_len += skb->len + spad + epad;
 432                } else {
 433                        /* Put back packet. */
 434                        skb_queue_head(&cfspi->qhead, skb);
 435                        break;
 436                }
 437        } while (pkts <= CAIF_MAX_SPI_PKTS);
 438
 439        /*
 440         * Send flow on if previously sent flow off
 441         * and now go below the low water mark
 442         */
 443        if (cfspi->flow_off_sent && cfspi->qhead.qlen < cfspi->qd_low_mark &&
 444                cfspi->cfdev.flowctrl) {
 445                cfspi->flow_off_sent = 0;
 446                cfspi->cfdev.flowctrl(cfspi->ndev, 1);
 447        }
 448
 449        return frm_len;
 450}
 451
 452static void cfspi_ss_cb(bool assert, struct cfspi_ifc *ifc)
 453{
 454        struct cfspi *cfspi = (struct cfspi *)ifc->priv;
 455
 456        /*
 457         * The slave device is the master on the link. Interrupts before the
 458         * slave has transmitted are considered spurious.
 459         */
 460        if (cfspi->slave && !cfspi->slave_talked) {
 461                printk(KERN_WARNING "CFSPI: Spurious SS interrupt.\n");
 462                return;
 463        }
 464
 465        if (!in_interrupt())
 466                spin_lock(&cfspi->lock);
 467        if (assert) {
 468                set_bit(SPI_SS_ON, &cfspi->state);
 469                set_bit(SPI_XFER, &cfspi->state);
 470        } else {
 471                set_bit(SPI_SS_OFF, &cfspi->state);
 472        }
 473        if (!in_interrupt())
 474                spin_unlock(&cfspi->lock);
 475
 476        /* Wake up the xfer thread. */
 477        if (assert)
 478                wake_up_interruptible(&cfspi->wait);
 479}
 480
 481static void cfspi_xfer_done_cb(struct cfspi_ifc *ifc)
 482{
 483        struct cfspi *cfspi = (struct cfspi *)ifc->priv;
 484
 485        /* Transfer done, complete work queue */
 486        complete(&cfspi->comp);
 487}
 488
 489static int cfspi_xmit(struct sk_buff *skb, struct net_device *dev)
 490{
 491        struct cfspi *cfspi = NULL;
 492        unsigned long flags;
 493        if (!dev)
 494                return -EINVAL;
 495
 496        cfspi = netdev_priv(dev);
 497
 498        skb_queue_tail(&cfspi->qhead, skb);
 499
 500        spin_lock_irqsave(&cfspi->lock, flags);
 501        if (!test_and_set_bit(SPI_XFER, &cfspi->state)) {
 502                /* Wake up xfer thread. */
 503                wake_up_interruptible(&cfspi->wait);
 504        }
 505        spin_unlock_irqrestore(&cfspi->lock, flags);
 506
 507        /* Send flow off if number of bytes is above high water mark */
 508        if (!cfspi->flow_off_sent &&
 509                cfspi->qhead.qlen > cfspi->qd_high_mark &&
 510                cfspi->cfdev.flowctrl) {
 511                cfspi->flow_off_sent = 1;
 512                cfspi->cfdev.flowctrl(cfspi->ndev, 0);
 513        }
 514
 515        return 0;
 516}
 517
 518int cfspi_rxfrm(struct cfspi *cfspi, u8 *buf, size_t len)
 519{
 520        u8 *src = buf;
 521
 522        caif_assert(buf != NULL);
 523
 524        do {
 525                int res;
 526                struct sk_buff *skb = NULL;
 527                int spad = 0;
 528                int epad = 0;
 529                u8 *dst = NULL;
 530                int pkt_len = 0;
 531
 532                /*
 533                 * Compute head offset i.e. number of bytes added to
 534                 * get the start of the payload aligned.
 535                 */
 536                if (spi_down_head_align > 1) {
 537                        spad = 1 + *src;
 538                        src += spad;
 539                }
 540
 541                /* Read length of CAIF frame (little endian). */
 542                pkt_len = *src;
 543                pkt_len |= ((*(src+1)) << 8) & 0xFF00;
 544                pkt_len += 2;   /* Add FCS fields. */
 545
 546                /* Get a suitable caif packet and copy in data. */
 547
 548                skb = netdev_alloc_skb(cfspi->ndev, pkt_len + 1);
 549                caif_assert(skb != NULL);
 550
 551                dst = skb_put(skb, pkt_len);
 552                memcpy(dst, src, pkt_len);
 553                src += pkt_len;
 554
 555                skb->protocol = htons(ETH_P_CAIF);
 556                skb_reset_mac_header(skb);
 557                skb->dev = cfspi->ndev;
 558
 559                /*
 560                 * Push received packet up the stack.
 561                 */
 562                if (!spi_loop)
 563                        res = netif_rx_ni(skb);
 564                else
 565                        res = cfspi_xmit(skb, cfspi->ndev);
 566
 567                if (!res) {
 568                        cfspi->ndev->stats.rx_packets++;
 569                        cfspi->ndev->stats.rx_bytes += pkt_len;
 570                } else
 571                        cfspi->ndev->stats.rx_dropped++;
 572
 573                /*
 574                 * Compute tail offset i.e. number of bytes added to
 575                 * get the complete CAIF frame aligned.
 576                 */
 577                epad = PAD_POW2((pkt_len + spad), spi_down_tail_align);
 578                src += epad;
 579        } while ((src - buf) < len);
 580
 581        return src - buf;
 582}
 583
 584static int cfspi_open(struct net_device *dev)
 585{
 586        netif_wake_queue(dev);
 587        return 0;
 588}
 589
 590static int cfspi_close(struct net_device *dev)
 591{
 592        netif_stop_queue(dev);
 593        return 0;
 594}
 595
 596static int cfspi_init(struct net_device *dev)
 597{
 598        int res = 0;
 599        struct cfspi *cfspi = netdev_priv(dev);
 600
 601        /* Set flow info. */
 602        cfspi->flow_off_sent = 0;
 603        cfspi->qd_low_mark = LOW_WATER_MARK;
 604        cfspi->qd_high_mark = HIGH_WATER_MARK;
 605
 606        /* Set slave info. */
 607        if (!strncmp(cfspi_spi_driver.driver.name, "cfspi_sspi", 10)) {
 608                cfspi->slave = true;
 609                cfspi->slave_talked = false;
 610        } else {
 611                cfspi->slave = false;
 612                cfspi->slave_talked = false;
 613        }
 614
 615        /* Allocate DMA buffers. */
 616        cfspi->xfer.va_tx[0] = dma_alloc(&cfspi->xfer.pa_tx[0]);
 617        if (!cfspi->xfer.va_tx[0]) {
 618                res = -ENODEV;
 619                goto err_dma_alloc_tx_0;
 620        }
 621
 622        cfspi->xfer.va_rx = dma_alloc(&cfspi->xfer.pa_rx);
 623
 624        if (!cfspi->xfer.va_rx) {
 625                res = -ENODEV;
 626                goto err_dma_alloc_rx;
 627        }
 628
 629        /* Initialize the work queue. */
 630        INIT_WORK(&cfspi->work, cfspi_xfer);
 631
 632        /* Initialize spin locks. */
 633        spin_lock_init(&cfspi->lock);
 634
 635        /* Initialize flow control state. */
 636        cfspi->flow_stop = false;
 637
 638        /* Initialize wait queue. */
 639        init_waitqueue_head(&cfspi->wait);
 640
 641        /* Create work thread. */
 642        cfspi->wq = create_singlethread_workqueue(dev->name);
 643        if (!cfspi->wq) {
 644                printk(KERN_WARNING "CFSPI: failed to create work queue.\n");
 645                res = -ENODEV;
 646                goto err_create_wq;
 647        }
 648
 649        /* Initialize work queue. */
 650        init_completion(&cfspi->comp);
 651
 652        /* Create debugfs entries. */
 653        dev_debugfs_add(cfspi);
 654
 655        /* Set up the ifc. */
 656        cfspi->ifc.ss_cb = cfspi_ss_cb;
 657        cfspi->ifc.xfer_done_cb = cfspi_xfer_done_cb;
 658        cfspi->ifc.priv = cfspi;
 659
 660        /* Add CAIF SPI device to list. */
 661        spin_lock(&cfspi_list_lock);
 662        list_add_tail(&cfspi->list, &cfspi_list);
 663        spin_unlock(&cfspi_list_lock);
 664
 665        /* Schedule the work queue. */
 666        queue_work(cfspi->wq, &cfspi->work);
 667
 668        return 0;
 669
 670 err_create_wq:
 671        dma_free(cfspi->xfer.va_rx, cfspi->xfer.pa_rx);
 672 err_dma_alloc_rx:
 673        dma_free(cfspi->xfer.va_tx[0], cfspi->xfer.pa_tx[0]);
 674 err_dma_alloc_tx_0:
 675        return res;
 676}
 677
 678static void cfspi_uninit(struct net_device *dev)
 679{
 680        struct cfspi *cfspi = netdev_priv(dev);
 681
 682        /* Remove from list. */
 683        spin_lock(&cfspi_list_lock);
 684        list_del(&cfspi->list);
 685        spin_unlock(&cfspi_list_lock);
 686
 687        cfspi->ndev = NULL;
 688        /* Free DMA buffers. */
 689        dma_free(cfspi->xfer.va_rx, cfspi->xfer.pa_rx);
 690        dma_free(cfspi->xfer.va_tx[0], cfspi->xfer.pa_tx[0]);
 691        set_bit(SPI_TERMINATE, &cfspi->state);
 692        wake_up_interruptible(&cfspi->wait);
 693        destroy_workqueue(cfspi->wq);
 694        /* Destroy debugfs directory and files. */
 695        dev_debugfs_rem(cfspi);
 696        return;
 697}
 698
 699static const struct net_device_ops cfspi_ops = {
 700        .ndo_open = cfspi_open,
 701        .ndo_stop = cfspi_close,
 702        .ndo_init = cfspi_init,
 703        .ndo_uninit = cfspi_uninit,
 704        .ndo_start_xmit = cfspi_xmit
 705};
 706
 707static void cfspi_setup(struct net_device *dev)
 708{
 709        struct cfspi *cfspi = netdev_priv(dev);
 710        dev->features = 0;
 711        dev->netdev_ops = &cfspi_ops;
 712        dev->type = ARPHRD_CAIF;
 713        dev->flags = IFF_NOARP | IFF_POINTOPOINT;
 714        dev->tx_queue_len = 0;
 715        dev->mtu = SPI_MAX_PAYLOAD_SIZE;
 716        dev->destructor = free_netdev;
 717        skb_queue_head_init(&cfspi->qhead);
 718        skb_queue_head_init(&cfspi->chead);
 719        cfspi->cfdev.link_select = CAIF_LINK_HIGH_BANDW;
 720        cfspi->cfdev.use_frag = false;
 721        cfspi->cfdev.use_stx = false;
 722        cfspi->cfdev.use_fcs = false;
 723        cfspi->ndev = dev;
 724}
 725
 726int cfspi_spi_probe(struct platform_device *pdev)
 727{
 728        struct cfspi *cfspi = NULL;
 729        struct net_device *ndev;
 730        struct cfspi_dev *dev;
 731        int res;
 732        dev = (struct cfspi_dev *)pdev->dev.platform_data;
 733
 734        ndev = alloc_netdev(sizeof(struct cfspi),
 735                        "cfspi%d", cfspi_setup);
 736        if (!dev)
 737                return -ENODEV;
 738
 739        cfspi = netdev_priv(ndev);
 740        netif_stop_queue(ndev);
 741        cfspi->ndev = ndev;
 742        cfspi->pdev = pdev;
 743
 744        /* Assign the SPI device. */
 745        cfspi->dev = dev;
 746        /* Assign the device ifc to this SPI interface. */
 747        dev->ifc = &cfspi->ifc;
 748
 749        /* Register network device. */
 750        res = register_netdev(ndev);
 751        if (res) {
 752                printk(KERN_ERR "CFSPI: Reg. error: %d.\n", res);
 753                goto err_net_reg;
 754        }
 755        return res;
 756
 757 err_net_reg:
 758        free_netdev(ndev);
 759
 760        return res;
 761}
 762
 763int cfspi_spi_remove(struct platform_device *pdev)
 764{
 765        /* Everything is done in cfspi_uninit(). */
 766        return 0;
 767}
 768
 769static void __exit cfspi_exit_module(void)
 770{
 771        struct list_head *list_node;
 772        struct list_head *n;
 773        struct cfspi *cfspi = NULL;
 774
 775        list_for_each_safe(list_node, n, &cfspi_list) {
 776                cfspi = list_entry(list_node, struct cfspi, list);
 777                unregister_netdev(cfspi->ndev);
 778        }
 779
 780        /* Destroy sysfs files. */
 781        driver_remove_file(&cfspi_spi_driver.driver,
 782                           &driver_attr_up_head_align);
 783        driver_remove_file(&cfspi_spi_driver.driver,
 784                           &driver_attr_up_tail_align);
 785        driver_remove_file(&cfspi_spi_driver.driver,
 786                           &driver_attr_down_head_align);
 787        driver_remove_file(&cfspi_spi_driver.driver,
 788                           &driver_attr_down_tail_align);
 789        driver_remove_file(&cfspi_spi_driver.driver, &driver_attr_frame_align);
 790        /* Unregister platform driver. */
 791        platform_driver_unregister(&cfspi_spi_driver);
 792        /* Destroy debugfs root directory. */
 793        driver_debugfs_remove();
 794}
 795
 796static int __init cfspi_init_module(void)
 797{
 798        int result;
 799
 800        /* Initialize spin lock. */
 801        spin_lock_init(&cfspi_list_lock);
 802
 803        /* Register platform driver. */
 804        result = platform_driver_register(&cfspi_spi_driver);
 805        if (result) {
 806                printk(KERN_ERR "Could not register platform SPI driver.\n");
 807                goto err_dev_register;
 808        }
 809
 810        /* Create sysfs files. */
 811        result =
 812            driver_create_file(&cfspi_spi_driver.driver,
 813                               &driver_attr_up_head_align);
 814        if (result) {
 815                printk(KERN_ERR "Sysfs creation failed 1.\n");
 816                goto err_create_up_head_align;
 817        }
 818
 819        result =
 820            driver_create_file(&cfspi_spi_driver.driver,
 821                               &driver_attr_up_tail_align);
 822        if (result) {
 823                printk(KERN_ERR "Sysfs creation failed 2.\n");
 824                goto err_create_up_tail_align;
 825        }
 826
 827        result =
 828            driver_create_file(&cfspi_spi_driver.driver,
 829                               &driver_attr_down_head_align);
 830        if (result) {
 831                printk(KERN_ERR "Sysfs creation failed 3.\n");
 832                goto err_create_down_head_align;
 833        }
 834
 835        result =
 836            driver_create_file(&cfspi_spi_driver.driver,
 837                               &driver_attr_down_tail_align);
 838        if (result) {
 839                printk(KERN_ERR "Sysfs creation failed 4.\n");
 840                goto err_create_down_tail_align;
 841        }
 842
 843        result =
 844            driver_create_file(&cfspi_spi_driver.driver,
 845                               &driver_attr_frame_align);
 846        if (result) {
 847                printk(KERN_ERR "Sysfs creation failed 5.\n");
 848                goto err_create_frame_align;
 849        }
 850        driver_debugfs_create();
 851        return result;
 852
 853 err_create_frame_align:
 854        driver_remove_file(&cfspi_spi_driver.driver,
 855                           &driver_attr_down_tail_align);
 856 err_create_down_tail_align:
 857        driver_remove_file(&cfspi_spi_driver.driver,
 858                           &driver_attr_down_head_align);
 859 err_create_down_head_align:
 860        driver_remove_file(&cfspi_spi_driver.driver,
 861                           &driver_attr_up_tail_align);
 862 err_create_up_tail_align:
 863        driver_remove_file(&cfspi_spi_driver.driver,
 864                           &driver_attr_up_head_align);
 865 err_create_up_head_align:
 866        platform_driver_unregister(&cfspi_spi_driver);
 867 err_dev_register:
 868        return result;
 869}
 870
 871module_init(cfspi_init_module);
 872module_exit(cfspi_exit_module);
 873