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