firewire: nosy: use flagless variants of spinlock accessors
[linux-2.6.git] / drivers / firewire / nosy.c
1 /*
2  * nosy - Snoop mode driver for TI PCILynx 1394 controllers
3  * Copyright (C) 2002-2007 Kristian Høgsberg
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #include <linux/errno.h>
21 #include <linux/fs.h>
22 #include <linux/init.h>
23 #include <linux/interrupt.h>
24 #include <linux/io.h>
25 #include <linux/kernel.h>
26 #include <linux/miscdevice.h>
27 #include <linux/module.h>
28 #include <linux/pci.h>
29 #include <linux/poll.h>
30 #include <linux/sched.h> /* required for linux/wait.h */
31 #include <linux/slab.h>
32 #include <linux/spinlock.h>
33 #include <linux/timex.h>
34 #include <linux/uaccess.h>
35 #include <linux/wait.h>
36
37 #include <asm/atomic.h>
38 #include <asm/byteorder.h>
39
40 #include "nosy.h"
41 #include "nosy-user.h"
42
43 #define TCODE_PHY_PACKET                0x10
44 #define PCI_DEVICE_ID_TI_PCILYNX        0x8000
45
46 #define notify(s, args...) printk(KERN_NOTICE s, ## args)
47 #define error(s, args...) printk(KERN_ERR s, ## args)
48 #define debug(s, args...) printk(KERN_DEBUG s, ## args)
49
50 static char driver_name[] = KBUILD_MODNAME;
51
52 struct pcl_status {
53         unsigned int transfer_count : 13;
54         unsigned int reserved0 : 1;
55         unsigned int ack_type : 1;
56         unsigned int ack : 4;
57         unsigned int rcv_speed : 2;
58         unsigned int rcv_dma_channel : 6;
59         unsigned int packet_complete : 1;
60         unsigned int packet_error : 1;
61         unsigned int master_error : 1;
62         unsigned int iso_mode : 1;
63         unsigned int self_id : 1;
64 };
65
66 /* this is the physical layout of a PCL, its size is 128 bytes */
67 struct pcl {
68         u32 next;
69         u32 async_error_next;
70         u32 user_data;
71         struct pcl_status pcl_status;
72         u32 remaining_transfer_count;
73         u32 next_data_buffer;
74         struct {
75                 u32 control;
76                 u32 pointer;
77         } buffer[13] __attribute__ ((packed));
78 } __attribute__ ((packed));
79
80 struct packet {
81         unsigned int length;
82         char data[0];
83 };
84
85 struct packet_buffer {
86         char *data;
87         size_t capacity;
88         long total_packet_count, lost_packet_count;
89         atomic_t size;
90         struct packet *head, *tail;
91         wait_queue_head_t wait;
92 };
93
94 struct pcilynx {
95         struct pci_dev *pci_device;
96         unsigned char *registers;
97
98         struct pcl *rcv_start_pcl, *rcv_pcl;
99         u32 *rcv_buffer;
100
101         dma_addr_t rcv_start_pcl_bus, rcv_pcl_bus, rcv_buffer_bus;
102
103         spinlock_t client_list_lock;
104         struct list_head client_list;
105
106         struct miscdevice misc;
107 };
108
109 struct client {
110         struct pcilynx *lynx;
111         u32 tcode_mask;
112         struct packet_buffer buffer;
113         struct list_head link;
114 };
115
116 #define MAX_MINORS 64
117 static struct pcilynx *minors[MAX_MINORS];
118
119 static int
120 packet_buffer_init(struct packet_buffer *buffer, size_t capacity)
121 {
122         buffer->data = kmalloc(capacity, GFP_KERNEL);
123         if (buffer->data == NULL)
124                 return -ENOMEM;
125         buffer->head = (struct packet *) buffer->data;
126         buffer->tail = (struct packet *) buffer->data;
127         buffer->capacity = capacity;
128         buffer->lost_packet_count = 0;
129         atomic_set(&buffer->size, 0);
130         init_waitqueue_head(&buffer->wait);
131
132         return 0;
133 }
134
135 static void
136 packet_buffer_destroy(struct packet_buffer *buffer)
137 {
138         kfree(buffer->data);
139 }
140
141 static int
142 packet_buffer_get(struct packet_buffer *buffer, void *data, size_t user_length)
143 {
144         size_t length;
145         char *end;
146
147         if (wait_event_interruptible(buffer->wait,
148                                      atomic_read(&buffer->size) > 0))
149                 return -ERESTARTSYS;
150
151         /* FIXME: Check length <= user_length. */
152
153         end = buffer->data + buffer->capacity;
154         length = buffer->head->length;
155
156         if (&buffer->head->data[length] < end) {
157                 if (copy_to_user(data, buffer->head->data, length))
158                         return -EFAULT;
159                 buffer->head = (struct packet *) &buffer->head->data[length];
160         } else {
161                 size_t split = end - buffer->head->data;
162
163                 if (copy_to_user(data, buffer->head->data, split))
164                         return -EFAULT;
165                 if (copy_to_user(data + split, buffer->data, length - split))
166                         return -EFAULT;
167                 buffer->head = (struct packet *) &buffer->data[length - split];
168         }
169
170         /*
171          * Decrease buffer->size as the last thing, since this is what
172          * keeps the interrupt from overwriting the packet we are
173          * retrieving from the buffer.
174          */
175         atomic_sub(sizeof(struct packet) + length, &buffer->size);
176
177         return length;
178 }
179
180 static void
181 packet_buffer_put(struct packet_buffer *buffer, void *data, size_t length)
182 {
183         char *end;
184
185         buffer->total_packet_count++;
186
187         if (buffer->capacity <
188             atomic_read(&buffer->size) + sizeof(struct packet) + length) {
189                 buffer->lost_packet_count++;
190                 return;
191         }
192
193         end = buffer->data + buffer->capacity;
194         buffer->tail->length = length;
195
196         if (&buffer->tail->data[length] < end) {
197                 memcpy(buffer->tail->data, data, length);
198                 buffer->tail = (struct packet *) &buffer->tail->data[length];
199         } else {
200                 size_t split = end - buffer->tail->data;
201
202                 memcpy(buffer->tail->data, data, split);
203                 memcpy(buffer->data, data + split, length - split);
204                 buffer->tail = (struct packet *) &buffer->data[length - split];
205         }
206
207         /* Finally, adjust buffer size and wake up userspace reader. */
208
209         atomic_add(sizeof(struct packet) + length, &buffer->size);
210         wake_up_interruptible(&buffer->wait);
211 }
212
213 static inline void
214 reg_write(struct pcilynx *lynx, int offset, u32 data)
215 {
216         writel(data, lynx->registers + offset);
217 }
218
219 static inline u32
220 reg_read(struct pcilynx *lynx, int offset)
221 {
222         return readl(lynx->registers + offset);
223 }
224
225 static inline void
226 reg_set_bits(struct pcilynx *lynx, int offset, u32 mask)
227 {
228         reg_write(lynx, offset, (reg_read(lynx, offset) | mask));
229 }
230
231 /*
232  * Maybe the pcl programs could be set up to just append data instead
233  * of using a whole packet.
234  */
235 static inline void
236 run_pcl(struct pcilynx *lynx, dma_addr_t pcl_bus,
237                            int dmachan)
238 {
239         reg_write(lynx, DMA0_CURRENT_PCL + dmachan * 0x20, pcl_bus);
240         reg_write(lynx, DMA0_CHAN_CTRL + dmachan * 0x20,
241                   DMA_CHAN_CTRL_ENABLE | DMA_CHAN_CTRL_LINK);
242 }
243
244 static int
245 set_phy_reg(struct pcilynx *lynx, int addr, int val)
246 {
247         if (addr > 15) {
248                 debug("PHY register address %d out of range\n", addr);
249                 return -1;
250         }
251
252         if (val > 0xff) {
253                 debug("PHY register value %d out of range\n", val);
254                 return -1;
255         }
256
257         reg_write(lynx, LINK_PHY, LINK_PHY_WRITE |
258                   LINK_PHY_ADDR(addr) | LINK_PHY_WDATA(val));
259
260         return 0;
261 }
262
263 static void
264 nosy_start_snoop(struct client *client)
265 {
266         spin_lock_irq(&client->lynx->client_list_lock);
267         list_add_tail(&client->link, &client->lynx->client_list);
268         spin_unlock_irq(&client->lynx->client_list_lock);
269 }
270
271 static void
272 nosy_stop_snoop(struct client *client)
273 {
274         spin_lock_irq(&client->lynx->client_list_lock);
275         list_del_init(&client->link);
276         spin_unlock_irq(&client->lynx->client_list_lock);
277 }
278
279 static struct client *
280 nosy_add_client(struct pcilynx *lynx)
281 {
282         struct client *client;
283
284         client = kmalloc(sizeof *client, GFP_KERNEL);
285         client->tcode_mask = ~0;
286         client->lynx = lynx;
287         INIT_LIST_HEAD(&client->link);
288
289         if (packet_buffer_init(&client->buffer, 128 * 1024) < 0) {
290                 kfree(client);
291                 debug("Failed to allocate packet buffer\n");
292                 return NULL;
293         }
294
295         return client;
296 }
297
298 static void
299 nosy_remove_client(struct client *client)
300 {
301         nosy_stop_snoop(client);
302         packet_buffer_destroy(&client->buffer);
303         kfree(client);
304 }
305
306 static int
307 nosy_open(struct inode *inode, struct file *file)
308 {
309         int minor = iminor(inode);
310
311         if (minor > MAX_MINORS || minors[minor] == NULL)
312                 return -ENODEV;
313
314         file->private_data = nosy_add_client(minors[minor]);
315         if (file->private_data == NULL)
316                 return -ENOMEM;
317         else
318                 return 0;
319 }
320
321 static int
322 nosy_release(struct inode *inode, struct file *file)
323 {
324         nosy_remove_client(file->private_data);
325
326         return 0;
327 }
328
329 static unsigned int
330 nosy_poll(struct file *file, poll_table *pt)
331 {
332         struct client *client = file->private_data;
333
334         poll_wait(file, &client->buffer.wait, pt);
335
336         if (atomic_read(&client->buffer.size) > 0)
337                 return POLLIN | POLLRDNORM;
338         else
339                 return 0;
340 }
341
342 static ssize_t
343 nosy_read(struct file *file, char *buffer, size_t count, loff_t *offset)
344 {
345         struct client *client = file->private_data;
346
347         return packet_buffer_get(&client->buffer, buffer, count);
348 }
349
350 static long
351 nosy_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
352 {
353         struct client *client = file->private_data;
354         spinlock_t *client_list_lock = &client->lynx->client_list_lock;
355         struct nosy_stats stats;
356
357         switch (cmd) {
358         case NOSY_IOC_GET_STATS:
359                 spin_lock_irq(client_list_lock);
360                 stats.total_packet_count = client->buffer.total_packet_count;
361                 stats.lost_packet_count  = client->buffer.lost_packet_count;
362                 spin_unlock_irq(client_list_lock);
363
364                 if (copy_to_user((void *) arg, &stats, sizeof stats))
365                         return -EFAULT;
366                 else
367                         return 0;
368
369         case NOSY_IOC_START:
370                 nosy_start_snoop(client);
371                 return 0;
372
373         case NOSY_IOC_STOP:
374                 nosy_stop_snoop(client);
375                 return 0;
376
377         case NOSY_IOC_FILTER:
378                 spin_lock_irq(client_list_lock);
379                 client->tcode_mask = arg;
380                 spin_unlock_irq(client_list_lock);
381                 return 0;
382
383         default:
384                 return -EINVAL;
385                 /* Flush buffer, configure filter. */
386         }
387 }
388
389 static const struct file_operations nosy_ops = {
390         .owner =                THIS_MODULE,
391         .read =                 nosy_read,
392         .unlocked_ioctl =       nosy_ioctl,
393         .poll =                 nosy_poll,
394         .open =                 nosy_open,
395         .release =              nosy_release,
396 };
397
398 #define PHY_PACKET_SIZE 12 /* 1 payload, 1 inverse, 1 ack = 3 quadlets */
399
400 struct link_packet {
401         unsigned int priority : 4;
402         unsigned int tcode : 4;
403         unsigned int rt : 2;
404         unsigned int tlabel : 6;
405         unsigned int destination : 16;
406 };
407
408 static void
409 packet_irq_handler(struct pcilynx *lynx)
410 {
411         struct client *client;
412         u32 tcode_mask;
413         size_t length;
414         struct link_packet *packet;
415         struct timeval tv;
416
417         /* FIXME: Also report rcv_speed. */
418
419         length = lynx->rcv_pcl->pcl_status.transfer_count;
420         packet = (struct link_packet *) &lynx->rcv_buffer[1];
421
422         do_gettimeofday(&tv);
423         lynx->rcv_buffer[0] = tv.tv_usec;
424
425         if (length == PHY_PACKET_SIZE)
426                 tcode_mask = 1 << TCODE_PHY_PACKET;
427         else
428                 tcode_mask = 1 << packet->tcode;
429
430         spin_lock(&lynx->client_list_lock);
431
432         list_for_each_entry(client, &lynx->client_list, link)
433                 if (client->tcode_mask & tcode_mask)
434                         packet_buffer_put(&client->buffer,
435                                           lynx->rcv_buffer, length + 4);
436
437         spin_unlock(&lynx->client_list_lock);
438 }
439
440 static void
441 bus_reset_irq_handler(struct pcilynx *lynx)
442 {
443         struct client *client;
444         struct timeval tv;
445
446         do_gettimeofday(&tv);
447
448         spin_lock(&lynx->client_list_lock);
449
450         list_for_each_entry(client, &lynx->client_list, link)
451                 packet_buffer_put(&client->buffer, &tv.tv_usec, 4);
452
453         spin_unlock(&lynx->client_list_lock);
454 }
455
456 static irqreturn_t
457 irq_handler(int irq, void *device)
458 {
459         struct pcilynx *lynx = device;
460         u32 pci_int_status;
461
462         pci_int_status = reg_read(lynx, PCI_INT_STATUS);
463
464         if ((pci_int_status & PCI_INT_INT_PEND) == 0)
465                 /* Not our interrupt, bail out quickly. */
466                 return IRQ_NONE;
467
468         if ((pci_int_status & PCI_INT_P1394_INT) != 0) {
469                 u32 link_int_status;
470
471                 link_int_status = reg_read(lynx, LINK_INT_STATUS);
472                 reg_write(lynx, LINK_INT_STATUS, link_int_status);
473
474                 if ((link_int_status & LINK_INT_PHY_BUSRESET) > 0)
475                         bus_reset_irq_handler(lynx);
476         }
477
478         /* Clear the PCI_INT_STATUS register only after clearing the
479          * LINK_INT_STATUS register; otherwise the PCI_INT_P1394 will
480          * be set again immediately. */
481
482         reg_write(lynx, PCI_INT_STATUS, pci_int_status);
483
484         if ((pci_int_status & PCI_INT_DMA0_HLT) > 0) {
485                 packet_irq_handler(lynx);
486                 run_pcl(lynx, lynx->rcv_start_pcl_bus, 0);
487         }
488
489         return IRQ_HANDLED;
490 }
491
492 static void
493 remove_card(struct pci_dev *dev)
494 {
495         struct pcilynx *lynx;
496
497         lynx = pci_get_drvdata(dev);
498         if (!lynx)
499                 return;
500         pci_set_drvdata(dev, NULL);
501
502         reg_write(lynx, PCI_INT_ENABLE, 0);
503         free_irq(lynx->pci_device->irq, lynx);
504
505         pci_free_consistent(lynx->pci_device, sizeof(struct pcl),
506                             lynx->rcv_start_pcl, lynx->rcv_start_pcl_bus);
507         pci_free_consistent(lynx->pci_device, sizeof(struct pcl),
508                             lynx->rcv_pcl, lynx->rcv_pcl_bus);
509         pci_free_consistent(lynx->pci_device, PAGE_SIZE,
510                             lynx->rcv_buffer, lynx->rcv_buffer_bus);
511
512         iounmap(lynx->registers);
513
514         minors[lynx->misc.minor] = NULL;
515         misc_deregister(&lynx->misc);
516
517         kfree(lynx);
518 }
519
520 #define RCV_BUFFER_SIZE (16 * 1024)
521
522 static int __devinit
523 add_card(struct pci_dev *dev, const struct pci_device_id *unused)
524 {
525         struct pcilynx *lynx;
526         u32 p, end;
527         int i;
528
529         if (pci_set_dma_mask(dev, 0xffffffff)) {
530                 error("DMA address limits not supported "
531                       "for PCILynx hardware\n");
532                 return -ENXIO;
533         }
534         if (pci_enable_device(dev)) {
535                 error("Failed to enable PCILynx hardware\n");
536                 return -ENXIO;
537         }
538         pci_set_master(dev);
539
540         lynx = kzalloc(sizeof *lynx, GFP_KERNEL);
541         if (lynx == NULL) {
542                 error("Failed to allocate control structure memory\n");
543                 return -ENOMEM;
544         }
545         lynx->pci_device = dev;
546         pci_set_drvdata(dev, lynx);
547
548         spin_lock_init(&lynx->client_list_lock);
549         INIT_LIST_HEAD(&lynx->client_list);
550
551         lynx->registers = ioremap_nocache(pci_resource_start(dev, 0),
552                                           PCILYNX_MAX_REGISTER);
553
554         lynx->rcv_start_pcl = pci_alloc_consistent(lynx->pci_device,
555                                 sizeof(struct pcl), &lynx->rcv_start_pcl_bus);
556         lynx->rcv_pcl = pci_alloc_consistent(lynx->pci_device,
557                                 sizeof(struct pcl), &lynx->rcv_pcl_bus);
558         lynx->rcv_buffer = pci_alloc_consistent(lynx->pci_device,
559                                 RCV_BUFFER_SIZE, &lynx->rcv_buffer_bus);
560         if (lynx->rcv_start_pcl == NULL ||
561             lynx->rcv_pcl == NULL ||
562             lynx->rcv_buffer == NULL) {
563                 /* FIXME: do proper error handling. */
564                 error("Failed to allocate receive buffer\n");
565                 return -ENOMEM;
566         }
567         lynx->rcv_start_pcl->next = lynx->rcv_pcl_bus;
568         lynx->rcv_pcl->next = PCL_NEXT_INVALID;
569         lynx->rcv_pcl->async_error_next = PCL_NEXT_INVALID;
570
571         lynx->rcv_pcl->buffer[0].control =
572                 PCL_CMD_RCV | PCL_BIGENDIAN | 2044;
573         lynx->rcv_pcl->buffer[0].pointer = lynx->rcv_buffer_bus + 4;
574         p = lynx->rcv_buffer_bus + 2048;
575         end = lynx->rcv_buffer_bus + RCV_BUFFER_SIZE;
576         for (i = 1; p < end; i++, p += 2048) {
577                 lynx->rcv_pcl->buffer[i].control =
578                         PCL_CMD_RCV | PCL_BIGENDIAN | 2048;
579                 lynx->rcv_pcl->buffer[i].pointer = p;
580         }
581         lynx->rcv_pcl->buffer[i - 1].control |= PCL_LAST_BUFF;
582
583         reg_set_bits(lynx, MISC_CONTROL, MISC_CONTROL_SWRESET);
584         /* Fix buggy cards with autoboot pin not tied low: */
585         reg_write(lynx, DMA0_CHAN_CTRL, 0);
586         reg_write(lynx, DMA_GLOBAL_REGISTER, 0x00 << 24);
587
588 #if 0
589         /* now, looking for PHY register set */
590         if ((get_phy_reg(lynx, 2) & 0xe0) == 0xe0) {
591                 lynx->phyic.reg_1394a = 1;
592                 PRINT(KERN_INFO, lynx->id,
593                       "found 1394a conform PHY (using extended register set)");
594                 lynx->phyic.vendor = get_phy_vendorid(lynx);
595                 lynx->phyic.product = get_phy_productid(lynx);
596         } else {
597                 lynx->phyic.reg_1394a = 0;
598                 PRINT(KERN_INFO, lynx->id, "found old 1394 PHY");
599         }
600 #endif
601
602         /* Setup the general receive FIFO max size. */
603         reg_write(lynx, FIFO_SIZES, 255);
604
605         reg_set_bits(lynx, PCI_INT_ENABLE, PCI_INT_DMA_ALL);
606
607         reg_write(lynx, LINK_INT_ENABLE,
608                   LINK_INT_PHY_TIME_OUT | LINK_INT_PHY_REG_RCVD |
609                   LINK_INT_PHY_BUSRESET | LINK_INT_IT_STUCK |
610                   LINK_INT_AT_STUCK | LINK_INT_SNTRJ |
611                   LINK_INT_TC_ERR | LINK_INT_GRF_OVER_FLOW |
612                   LINK_INT_ITF_UNDER_FLOW | LINK_INT_ATF_UNDER_FLOW);
613
614         /* Disable the L flag in self ID packets. */
615         set_phy_reg(lynx, 4, 0);
616
617         /* Put this baby into snoop mode */
618         reg_set_bits(lynx, LINK_CONTROL, LINK_CONTROL_SNOOP_ENABLE);
619
620         run_pcl(lynx, lynx->rcv_start_pcl_bus, 0);
621
622         if (request_irq(dev->irq, irq_handler, IRQF_SHARED,
623                         driver_name, lynx)) {
624                 error("Failed to allocate shared interrupt %d\n", dev->irq);
625                 return -EIO;
626         }
627
628         lynx->misc.parent = &dev->dev;
629         lynx->misc.minor = MISC_DYNAMIC_MINOR;
630         lynx->misc.name = "nosy";
631         lynx->misc.fops = &nosy_ops;
632         if (misc_register(&lynx->misc)) {
633                 error("Failed to register misc char device\n");
634                 return -ENOMEM;
635         }
636         minors[lynx->misc.minor] = lynx;
637
638         notify("Initialized PCILynx IEEE1394 card, irq=%d\n", dev->irq);
639
640         return 0;
641 }
642
643 static struct pci_device_id pci_table[] __devinitdata = {
644         {
645                 .vendor =    PCI_VENDOR_ID_TI,
646                 .device =    PCI_DEVICE_ID_TI_PCILYNX,
647                 .subvendor = PCI_ANY_ID,
648                 .subdevice = PCI_ANY_ID,
649         },
650         { }     /* Terminating entry */
651 };
652
653 static struct pci_driver lynx_pci_driver = {
654         .name =         driver_name,
655         .id_table =     pci_table,
656         .probe =        add_card,
657         .remove =       remove_card,
658 };
659
660 MODULE_AUTHOR("Kristian Hoegsberg");
661 MODULE_DESCRIPTION("Snoop mode driver for TI pcilynx 1394 controllers");
662 MODULE_LICENSE("GPL");
663 MODULE_DEVICE_TABLE(pci, pci_table);
664
665 static int __init nosy_init(void)
666 {
667         return pci_register_driver(&lynx_pci_driver);
668 }
669
670 static void __exit nosy_cleanup(void)
671 {
672         pci_unregister_driver(&lynx_pci_driver);
673
674         notify("Unloaded %s.\n", driver_name);
675 }
676
677 module_init(nosy_init);
678 module_exit(nosy_cleanup);