drivers/net/caif/caif

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

DEFINITIONS
