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