96391c36fa74c77a66b47add6cf188f069fcce0a
[linux-2.6.git] / drivers / net / caif / caif_spi.c
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
31 MODULE_LICENSE("GPL");
32 MODULE_AUTHOR("Daniel Martensson<daniel.martensson@stericsson.com>");
33 MODULE_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
38 static bool spi_loop;
39 module_param(spi_loop, bool, S_IRUGO);
40 MODULE_PARM_DESC(spi_loop, "SPI running in loopback mode.");
41
42 /* SPI frame alignment. */
43 module_param(spi_frm_align, int, S_IRUGO);
44 MODULE_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  */
50 module_param(spi_up_head_align, int, S_IRUGO);
51 MODULE_PARM_DESC(spi_up_head_align, "SPI uplink head alignment.");
52
53 module_param(spi_up_tail_align, int, S_IRUGO);
54 MODULE_PARM_DESC(spi_up_tail_align, "SPI uplink tail alignment.");
55
56 module_param(spi_down_head_align, int, S_IRUGO);
57 MODULE_PARM_DESC(spi_down_head_align, "SPI downlink head alignment.");
58
59 module_param(spi_down_tail_align, int, S_IRUGO);
60 MODULE_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  */
83 static inline void *dma_alloc(dma_addr_t *daddr)
84 {
85         return kmalloc(SPI_DMA_BUF_LEN, GFP_KERNEL);
86 }
87
88 static inline void dma_free(void *cpu_addr, dma_addr_t handle)
89 {
90         kfree(cpu_addr);
91 }
92
93 #else
94
95 static 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
101 static 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
111 static struct dentry *dbgfs_root;
112
113 static inline void driver_debugfs_create(void)
114 {
115         dbgfs_root = debugfs_create_dir(cfspi_spi_driver.driver.name, NULL);
116 }
117
118 static inline void driver_debugfs_remove(void)
119 {
120         debugfs_remove(dbgfs_root);
121 }
122
123 static 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
130 static int dbgfs_open(struct inode *inode, struct file *file)
131 {
132         file->private_data = inode->i_private;
133         return 0;
134 }
135
136 static 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
182 static 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
208 static 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[0],
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
245 static const struct file_operations dbgfs_state_fops = {
246         .open = dbgfs_open,
247         .read = dbgfs_state,
248         .owner = THIS_MODULE
249 };
250
251 static const struct file_operations dbgfs_frame_fops = {
252         .open = dbgfs_open,
253         .read = dbgfs_frame,
254         .owner = THIS_MODULE
255 };
256
257 static 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
268 inline void cfspi_dbg_state(struct cfspi *cfspi, int state)
269 {
270         cfspi->dbg_state = state;
271 };
272 #else
273
274 static inline void driver_debugfs_create(void)
275 {
276 }
277
278 static inline void driver_debugfs_remove(void)
279 {
280 }
281
282 static inline void dev_debugfs_add(struct cfspi *cfspi)
283 {
284 }
285
286 static inline void dev_debugfs_rem(struct cfspi *cfspi)
287 {
288 }
289
290 inline void cfspi_dbg_state(struct cfspi *cfspi, int state)
291 {
292 }
293 #endif                          /* CONFIG_DEBUG_FS */
294
295 static LIST_HEAD(cfspi_list);
296 static spinlock_t cfspi_list_lock;
297
298 /* SPI uplink head alignment. */
299 static 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
304 static DRIVER_ATTR(up_head_align, S_IRUSR, show_up_head_align, NULL);
305
306 /* SPI uplink tail alignment. */
307 static 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
312 static DRIVER_ATTR(up_tail_align, S_IRUSR, show_up_tail_align, NULL);
313
314 /* SPI downlink head alignment. */
315 static 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
320 static DRIVER_ATTR(down_head_align, S_IRUSR, show_down_head_align, NULL);
321
322 /* SPI downlink tail alignment. */
323 static 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
328 static DRIVER_ATTR(down_tail_align, S_IRUSR, show_down_tail_align, NULL);
329
330 /* SPI frame alignment. */
331 static ssize_t show_frame_align(struct device_driver *driver, char *buf)
332 {
333         return sprintf(buf, "%d\n", spi_frm_align);
334 }
335
336 static DRIVER_ATTR(frame_align, S_IRUSR, show_frame_align, NULL);
337
338 int 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
392 int 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
459 static 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
488 static 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
496 static 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
525 int 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
591 static int cfspi_open(struct net_device *dev)
592 {
593         netif_wake_queue(dev);
594         return 0;
595 }
596
597 static int cfspi_close(struct net_device *dev)
598 {
599         netif_stop_queue(dev);
600         return 0;
601 }
602
603 static int cfspi_init(struct net_device *dev)
604 {
605         int res = 0;
606         struct cfspi *cfspi = netdev_priv(dev);
607
608         /* Set flow info. */
609         cfspi->flow_off_sent = 0;
610         cfspi->qd_low_mark = LOW_WATER_MARK;
611         cfspi->qd_high_mark = HIGH_WATER_MARK;
612
613         /* Set slave info. */
614         if (!strncmp(cfspi_spi_driver.driver.name, "cfspi_sspi", 10)) {
615                 cfspi->slave = true;
616                 cfspi->slave_talked = false;
617         } else {
618                 cfspi->slave = false;
619                 cfspi->slave_talked = false;
620         }
621
622         /* Allocate DMA buffers. */
623         cfspi->xfer.va_tx[0] = dma_alloc(&cfspi->xfer.pa_tx[0]);
624         if (!cfspi->xfer.va_tx[0]) {
625                 res = -ENODEV;
626                 goto err_dma_alloc_tx_0;
627         }
628
629         cfspi->xfer.va_rx = dma_alloc(&cfspi->xfer.pa_rx);
630
631         if (!cfspi->xfer.va_rx) {
632                 res = -ENODEV;
633                 goto err_dma_alloc_rx;
634         }
635
636         /* Initialize the work queue. */
637         INIT_WORK(&cfspi->work, cfspi_xfer);
638
639         /* Initialize spin locks. */
640         spin_lock_init(&cfspi->lock);
641
642         /* Initialize flow control state. */
643         cfspi->flow_stop = false;
644
645         /* Initialize wait queue. */
646         init_waitqueue_head(&cfspi->wait);
647
648         /* Create work thread. */
649         cfspi->wq = create_singlethread_workqueue(dev->name);
650         if (!cfspi->wq) {
651                 printk(KERN_WARNING "CFSPI: failed to create work queue.\n");
652                 res = -ENODEV;
653                 goto err_create_wq;
654         }
655
656         /* Initialize work queue. */
657         init_completion(&cfspi->comp);
658
659         /* Create debugfs entries. */
660         dev_debugfs_add(cfspi);
661
662         /* Set up the ifc. */
663         cfspi->ifc.ss_cb = cfspi_ss_cb;
664         cfspi->ifc.xfer_done_cb = cfspi_xfer_done_cb;
665         cfspi->ifc.priv = cfspi;
666
667         /* Add CAIF SPI device to list. */
668         spin_lock(&cfspi_list_lock);
669         list_add_tail(&cfspi->list, &cfspi_list);
670         spin_unlock(&cfspi_list_lock);
671
672         /* Schedule the work queue. */
673         queue_work(cfspi->wq, &cfspi->work);
674
675         return 0;
676
677  err_create_wq:
678         dma_free(cfspi->xfer.va_rx, cfspi->xfer.pa_rx);
679  err_dma_alloc_rx:
680         dma_free(cfspi->xfer.va_tx[0], cfspi->xfer.pa_tx[0]);
681  err_dma_alloc_tx_0:
682         return res;
683 }
684
685 static void cfspi_uninit(struct net_device *dev)
686 {
687         struct cfspi *cfspi = netdev_priv(dev);
688
689         /* Remove from list. */
690         spin_lock(&cfspi_list_lock);
691         list_del(&cfspi->list);
692         spin_unlock(&cfspi_list_lock);
693
694         cfspi->ndev = NULL;
695         /* Free DMA buffers. */
696         dma_free(cfspi->xfer.va_rx, cfspi->xfer.pa_rx);
697         dma_free(cfspi->xfer.va_tx[0], cfspi->xfer.pa_tx[0]);
698         set_bit(SPI_TERMINATE, &cfspi->state);
699         wake_up_interruptible(&cfspi->wait);
700         destroy_workqueue(cfspi->wq);
701         /* Destroy debugfs directory and files. */
702         dev_debugfs_rem(cfspi);
703         return;
704 }
705
706 static const struct net_device_ops cfspi_ops = {
707         .ndo_open = cfspi_open,
708         .ndo_stop = cfspi_close,
709         .ndo_init = cfspi_init,
710         .ndo_uninit = cfspi_uninit,
711         .ndo_start_xmit = cfspi_xmit
712 };
713
714 static void cfspi_setup(struct net_device *dev)
715 {
716         struct cfspi *cfspi = netdev_priv(dev);
717         dev->features = 0;
718         dev->netdev_ops = &cfspi_ops;
719         dev->type = ARPHRD_CAIF;
720         dev->flags = IFF_NOARP | IFF_POINTOPOINT;
721         dev->tx_queue_len = 0;
722         dev->mtu = SPI_MAX_PAYLOAD_SIZE;
723         dev->destructor = free_netdev;
724         skb_queue_head_init(&cfspi->qhead);
725         skb_queue_head_init(&cfspi->chead);
726         cfspi->cfdev.link_select = CAIF_LINK_HIGH_BANDW;
727         cfspi->cfdev.use_frag = false;
728         cfspi->cfdev.use_stx = false;
729         cfspi->cfdev.use_fcs = false;
730         cfspi->ndev = dev;
731 }
732
733 int cfspi_spi_probe(struct platform_device *pdev)
734 {
735         struct cfspi *cfspi = NULL;
736         struct net_device *ndev;
737         struct cfspi_dev *dev;
738         int res;
739         dev = (struct cfspi_dev *)pdev->dev.platform_data;
740
741         ndev = alloc_netdev(sizeof(struct cfspi),
742                         "cfspi%d", cfspi_setup);
743         if (!dev)
744                 return -ENODEV;
745
746         cfspi = netdev_priv(ndev);
747         netif_stop_queue(ndev);
748         cfspi->ndev = ndev;
749         cfspi->pdev = pdev;
750
751         /* Assign the SPI device. */
752         cfspi->dev = dev;
753         /* Assign the device ifc to this SPI interface. */
754         dev->ifc = &cfspi->ifc;
755
756         /* Register network device. */
757         res = register_netdev(ndev);
758         if (res) {
759                 printk(KERN_ERR "CFSPI: Reg. error: %d.\n", res);
760                 goto err_net_reg;
761         }
762         return res;
763
764  err_net_reg:
765         free_netdev(ndev);
766
767         return res;
768 }
769
770 int cfspi_spi_remove(struct platform_device *pdev)
771 {
772         /* Everything is done in cfspi_uninit(). */
773         return 0;
774 }
775
776 static 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                 unregister_netdev(cfspi->ndev);
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
803 static 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
877 module_init(cfspi_init_module);
878 module_exit(cfspi_exit_module);