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