1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * nosy - Snoop mode driver for TI PCILynx 1394 controllers
4 * Copyright (C) 2002-2007 Kristian Høgsberg
7 #include <linux/device.h>
8 #include <linux/errno.h>
10 #include <linux/init.h>
11 #include <linux/interrupt.h>
13 #include <linux/kernel.h>
14 #include <linux/kref.h>
15 #include <linux/miscdevice.h>
16 #include <linux/module.h>
17 #include <linux/mutex.h>
18 #include <linux/pci.h>
19 #include <linux/poll.h>
20 #include <linux/sched.h> /* required for linux/wait.h */
21 #include <linux/slab.h>
22 #include <linux/spinlock.h>
23 #include <linux/time64.h>
24 #include <linux/timex.h>
25 #include <linux/uaccess.h>
26 #include <linux/wait.h>
27 #include <linux/dma-mapping.h>
28 #include <linux/atomic.h>
29 #include <asm/byteorder.h>
32 #include "nosy-user.h"
34 #define TCODE_PHY_PACKET 0x10
35 #define PCI_DEVICE_ID_TI_PCILYNX 0x8000
37 static char driver_name
[] = KBUILD_MODNAME
;
39 /* this is the physical layout of a PCL, its size is 128 bytes */
42 __le32 async_error_next
;
45 __le32 remaining_transfer_count
;
46 __le32 next_data_buffer
;
58 struct packet_buffer
{
61 long total_packet_count
, lost_packet_count
;
63 struct packet
*head
, *tail
;
64 wait_queue_head_t wait
;
68 struct pci_dev
*pci_device
;
69 __iomem
char *registers
;
71 struct pcl
*rcv_start_pcl
, *rcv_pcl
;
74 dma_addr_t rcv_start_pcl_bus
, rcv_pcl_bus
, rcv_buffer_bus
;
76 spinlock_t client_list_lock
;
77 struct list_head client_list
;
79 struct miscdevice misc
;
80 struct list_head link
;
84 static inline struct pcilynx
*
85 lynx_get(struct pcilynx
*lynx
)
87 kref_get(&lynx
->kref
);
93 lynx_release(struct kref
*kref
)
95 kfree(container_of(kref
, struct pcilynx
, kref
));
99 lynx_put(struct pcilynx
*lynx
)
101 kref_put(&lynx
->kref
, lynx_release
);
105 struct pcilynx
*lynx
;
107 struct packet_buffer buffer
;
108 struct list_head link
;
111 static DEFINE_MUTEX(card_mutex
);
112 static LIST_HEAD(card_list
);
115 packet_buffer_init(struct packet_buffer
*buffer
, size_t capacity
)
117 buffer
->data
= kmalloc(capacity
, GFP_KERNEL
);
118 if (buffer
->data
== NULL
)
120 buffer
->head
= (struct packet
*) buffer
->data
;
121 buffer
->tail
= (struct packet
*) buffer
->data
;
122 buffer
->capacity
= capacity
;
123 buffer
->lost_packet_count
= 0;
124 atomic_set(&buffer
->size
, 0);
125 init_waitqueue_head(&buffer
->wait
);
131 packet_buffer_destroy(struct packet_buffer
*buffer
)
137 packet_buffer_get(struct client
*client
, char __user
*data
, size_t user_length
)
139 struct packet_buffer
*buffer
= &client
->buffer
;
143 if (wait_event_interruptible(buffer
->wait
,
144 atomic_read(&buffer
->size
) > 0) ||
145 list_empty(&client
->lynx
->link
))
148 if (atomic_read(&buffer
->size
) == 0)
151 /* FIXME: Check length <= user_length. */
153 end
= buffer
->data
+ buffer
->capacity
;
154 length
= buffer
->head
->length
;
156 if (&buffer
->head
->data
[length
] < end
) {
157 if (copy_to_user(data
, buffer
->head
->data
, length
))
159 buffer
->head
= (struct packet
*) &buffer
->head
->data
[length
];
161 size_t split
= end
- buffer
->head
->data
;
163 if (copy_to_user(data
, buffer
->head
->data
, split
))
165 if (copy_to_user(data
+ split
, buffer
->data
, length
- split
))
167 buffer
->head
= (struct packet
*) &buffer
->data
[length
- split
];
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.
175 atomic_sub(sizeof(struct packet
) + length
, &buffer
->size
);
181 packet_buffer_put(struct packet_buffer
*buffer
, void *data
, size_t length
)
185 buffer
->total_packet_count
++;
187 if (buffer
->capacity
<
188 atomic_read(&buffer
->size
) + sizeof(struct packet
) + length
) {
189 buffer
->lost_packet_count
++;
193 end
= buffer
->data
+ buffer
->capacity
;
194 buffer
->tail
->length
= length
;
196 if (&buffer
->tail
->data
[length
] < end
) {
197 memcpy(buffer
->tail
->data
, data
, length
);
198 buffer
->tail
= (struct packet
*) &buffer
->tail
->data
[length
];
200 size_t split
= end
- buffer
->tail
->data
;
202 memcpy(buffer
->tail
->data
, data
, split
);
203 memcpy(buffer
->data
, data
+ split
, length
- split
);
204 buffer
->tail
= (struct packet
*) &buffer
->data
[length
- split
];
207 /* Finally, adjust buffer size and wake up userspace reader. */
209 atomic_add(sizeof(struct packet
) + length
, &buffer
->size
);
210 wake_up_interruptible(&buffer
->wait
);
214 reg_write(struct pcilynx
*lynx
, int offset
, u32 data
)
216 writel(data
, lynx
->registers
+ offset
);
220 reg_read(struct pcilynx
*lynx
, int offset
)
222 return readl(lynx
->registers
+ offset
);
226 reg_set_bits(struct pcilynx
*lynx
, int offset
, u32 mask
)
228 reg_write(lynx
, offset
, (reg_read(lynx
, offset
) | mask
));
232 * Maybe the pcl programs could be set up to just append data instead
233 * of using a whole packet.
236 run_pcl(struct pcilynx
*lynx
, dma_addr_t pcl_bus
,
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
);
245 set_phy_reg(struct pcilynx
*lynx
, int addr
, int val
)
248 dev_err(&lynx
->pci_device
->dev
,
249 "PHY register address %d out of range\n", addr
);
253 dev_err(&lynx
->pci_device
->dev
,
254 "PHY register value %d out of range\n", val
);
257 reg_write(lynx
, LINK_PHY
, LINK_PHY_WRITE
|
258 LINK_PHY_ADDR(addr
) | LINK_PHY_WDATA(val
));
264 nosy_open(struct inode
*inode
, struct file
*file
)
266 int minor
= iminor(inode
);
267 struct client
*client
;
268 struct pcilynx
*tmp
, *lynx
= NULL
;
270 mutex_lock(&card_mutex
);
271 list_for_each_entry(tmp
, &card_list
, link
)
272 if (tmp
->misc
.minor
== minor
) {
273 lynx
= lynx_get(tmp
);
276 mutex_unlock(&card_mutex
);
280 client
= kmalloc(sizeof *client
, GFP_KERNEL
);
284 client
->tcode_mask
= ~0;
286 INIT_LIST_HEAD(&client
->link
);
288 if (packet_buffer_init(&client
->buffer
, 128 * 1024) < 0)
291 file
->private_data
= client
;
293 return stream_open(inode
, file
);
302 nosy_release(struct inode
*inode
, struct file
*file
)
304 struct client
*client
= file
->private_data
;
305 struct pcilynx
*lynx
= client
->lynx
;
307 spin_lock_irq(&lynx
->client_list_lock
);
308 list_del_init(&client
->link
);
309 spin_unlock_irq(&lynx
->client_list_lock
);
311 packet_buffer_destroy(&client
->buffer
);
319 nosy_poll(struct file
*file
, poll_table
*pt
)
321 struct client
*client
= file
->private_data
;
324 poll_wait(file
, &client
->buffer
.wait
, pt
);
326 if (atomic_read(&client
->buffer
.size
) > 0)
327 ret
= EPOLLIN
| EPOLLRDNORM
;
329 if (list_empty(&client
->lynx
->link
))
336 nosy_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*offset
)
338 struct client
*client
= file
->private_data
;
340 return packet_buffer_get(client
, buffer
, count
);
344 nosy_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
346 struct client
*client
= file
->private_data
;
347 spinlock_t
*client_list_lock
= &client
->lynx
->client_list_lock
;
348 struct nosy_stats stats
;
352 case NOSY_IOC_GET_STATS
:
353 spin_lock_irq(client_list_lock
);
354 stats
.total_packet_count
= client
->buffer
.total_packet_count
;
355 stats
.lost_packet_count
= client
->buffer
.lost_packet_count
;
356 spin_unlock_irq(client_list_lock
);
358 if (copy_to_user((void __user
*) arg
, &stats
, sizeof stats
))
365 spin_lock_irq(client_list_lock
);
366 if (list_empty(&client
->link
)) {
367 list_add_tail(&client
->link
, &client
->lynx
->client_list
);
370 spin_unlock_irq(client_list_lock
);
375 spin_lock_irq(client_list_lock
);
376 list_del_init(&client
->link
);
377 spin_unlock_irq(client_list_lock
);
381 case NOSY_IOC_FILTER
:
382 spin_lock_irq(client_list_lock
);
383 client
->tcode_mask
= arg
;
384 spin_unlock_irq(client_list_lock
);
390 /* Flush buffer, configure filter. */
394 static const struct file_operations nosy_ops
= {
395 .owner
= THIS_MODULE
,
397 .unlocked_ioctl
= nosy_ioctl
,
400 .release
= nosy_release
,
403 #define PHY_PACKET_SIZE 12 /* 1 payload, 1 inverse, 1 ack = 3 quadlets */
406 packet_irq_handler(struct pcilynx
*lynx
)
408 struct client
*client
;
409 u32 tcode_mask
, tcode
, timestamp
;
411 struct timespec64 ts64
;
413 /* FIXME: Also report rcv_speed. */
415 length
= __le32_to_cpu(lynx
->rcv_pcl
->pcl_status
) & 0x00001fff;
416 tcode
= __le32_to_cpu(lynx
->rcv_buffer
[1]) >> 4 & 0xf;
418 ktime_get_real_ts64(&ts64
);
419 timestamp
= ts64
.tv_nsec
/ NSEC_PER_USEC
;
420 lynx
->rcv_buffer
[0] = (__force __le32
)timestamp
;
422 if (length
== PHY_PACKET_SIZE
)
423 tcode_mask
= 1 << TCODE_PHY_PACKET
;
425 tcode_mask
= 1 << tcode
;
427 spin_lock(&lynx
->client_list_lock
);
429 list_for_each_entry(client
, &lynx
->client_list
, link
)
430 if (client
->tcode_mask
& tcode_mask
)
431 packet_buffer_put(&client
->buffer
,
432 lynx
->rcv_buffer
, length
+ 4);
434 spin_unlock(&lynx
->client_list_lock
);
438 bus_reset_irq_handler(struct pcilynx
*lynx
)
440 struct client
*client
;
441 struct timespec64 ts64
;
444 ktime_get_real_ts64(&ts64
);
445 timestamp
= ts64
.tv_nsec
/ NSEC_PER_USEC
;
447 spin_lock(&lynx
->client_list_lock
);
449 list_for_each_entry(client
, &lynx
->client_list
, link
)
450 packet_buffer_put(&client
->buffer
, ×tamp
, 4);
452 spin_unlock(&lynx
->client_list_lock
);
456 irq_handler(int irq
, void *device
)
458 struct pcilynx
*lynx
= device
;
461 pci_int_status
= reg_read(lynx
, PCI_INT_STATUS
);
463 if (pci_int_status
== ~0)
464 /* Card was ejected. */
467 if ((pci_int_status
& PCI_INT_INT_PEND
) == 0)
468 /* Not our interrupt, bail out quickly. */
471 if ((pci_int_status
& PCI_INT_P1394_INT
) != 0) {
474 link_int_status
= reg_read(lynx
, LINK_INT_STATUS
);
475 reg_write(lynx
, LINK_INT_STATUS
, link_int_status
);
477 if ((link_int_status
& LINK_INT_PHY_BUSRESET
) > 0)
478 bus_reset_irq_handler(lynx
);
481 /* Clear the PCI_INT_STATUS register only after clearing the
482 * LINK_INT_STATUS register; otherwise the PCI_INT_P1394 will
483 * be set again immediately. */
485 reg_write(lynx
, PCI_INT_STATUS
, pci_int_status
);
487 if ((pci_int_status
& PCI_INT_DMA0_HLT
) > 0) {
488 packet_irq_handler(lynx
);
489 run_pcl(lynx
, lynx
->rcv_start_pcl_bus
, 0);
496 remove_card(struct pci_dev
*dev
)
498 struct pcilynx
*lynx
= pci_get_drvdata(dev
);
499 struct client
*client
;
501 mutex_lock(&card_mutex
);
502 list_del_init(&lynx
->link
);
503 misc_deregister(&lynx
->misc
);
504 mutex_unlock(&card_mutex
);
506 reg_write(lynx
, PCI_INT_ENABLE
, 0);
507 free_irq(lynx
->pci_device
->irq
, lynx
);
509 spin_lock_irq(&lynx
->client_list_lock
);
510 list_for_each_entry(client
, &lynx
->client_list
, link
)
511 wake_up_interruptible(&client
->buffer
.wait
);
512 spin_unlock_irq(&lynx
->client_list_lock
);
514 pci_free_consistent(lynx
->pci_device
, sizeof(struct pcl
),
515 lynx
->rcv_start_pcl
, lynx
->rcv_start_pcl_bus
);
516 pci_free_consistent(lynx
->pci_device
, sizeof(struct pcl
),
517 lynx
->rcv_pcl
, lynx
->rcv_pcl_bus
);
518 pci_free_consistent(lynx
->pci_device
, PAGE_SIZE
,
519 lynx
->rcv_buffer
, lynx
->rcv_buffer_bus
);
521 iounmap(lynx
->registers
);
522 pci_disable_device(dev
);
526 #define RCV_BUFFER_SIZE (16 * 1024)
529 add_card(struct pci_dev
*dev
, const struct pci_device_id
*unused
)
531 struct pcilynx
*lynx
;
535 if (pci_set_dma_mask(dev
, DMA_BIT_MASK(32))) {
537 "DMA address limits not supported for PCILynx hardware\n");
540 if (pci_enable_device(dev
)) {
541 dev_err(&dev
->dev
, "Failed to enable PCILynx hardware\n");
546 lynx
= kzalloc(sizeof *lynx
, GFP_KERNEL
);
548 dev_err(&dev
->dev
, "Failed to allocate control structure\n");
552 lynx
->pci_device
= dev
;
553 pci_set_drvdata(dev
, lynx
);
555 spin_lock_init(&lynx
->client_list_lock
);
556 INIT_LIST_HEAD(&lynx
->client_list
);
557 kref_init(&lynx
->kref
);
559 lynx
->registers
= ioremap_nocache(pci_resource_start(dev
, 0),
560 PCILYNX_MAX_REGISTER
);
561 if (lynx
->registers
== NULL
) {
562 dev_err(&dev
->dev
, "Failed to map registers\n");
564 goto fail_deallocate_lynx
;
567 lynx
->rcv_start_pcl
= pci_alloc_consistent(lynx
->pci_device
,
568 sizeof(struct pcl
), &lynx
->rcv_start_pcl_bus
);
569 lynx
->rcv_pcl
= pci_alloc_consistent(lynx
->pci_device
,
570 sizeof(struct pcl
), &lynx
->rcv_pcl_bus
);
571 lynx
->rcv_buffer
= pci_alloc_consistent(lynx
->pci_device
,
572 RCV_BUFFER_SIZE
, &lynx
->rcv_buffer_bus
);
573 if (lynx
->rcv_start_pcl
== NULL
||
574 lynx
->rcv_pcl
== NULL
||
575 lynx
->rcv_buffer
== NULL
) {
576 dev_err(&dev
->dev
, "Failed to allocate receive buffer\n");
578 goto fail_deallocate_buffers
;
580 lynx
->rcv_start_pcl
->next
= cpu_to_le32(lynx
->rcv_pcl_bus
);
581 lynx
->rcv_pcl
->next
= cpu_to_le32(PCL_NEXT_INVALID
);
582 lynx
->rcv_pcl
->async_error_next
= cpu_to_le32(PCL_NEXT_INVALID
);
584 lynx
->rcv_pcl
->buffer
[0].control
=
585 cpu_to_le32(PCL_CMD_RCV
| PCL_BIGENDIAN
| 2044);
586 lynx
->rcv_pcl
->buffer
[0].pointer
=
587 cpu_to_le32(lynx
->rcv_buffer_bus
+ 4);
588 p
= lynx
->rcv_buffer_bus
+ 2048;
589 end
= lynx
->rcv_buffer_bus
+ RCV_BUFFER_SIZE
;
590 for (i
= 1; p
< end
; i
++, p
+= 2048) {
591 lynx
->rcv_pcl
->buffer
[i
].control
=
592 cpu_to_le32(PCL_CMD_RCV
| PCL_BIGENDIAN
| 2048);
593 lynx
->rcv_pcl
->buffer
[i
].pointer
= cpu_to_le32(p
);
595 lynx
->rcv_pcl
->buffer
[i
- 1].control
|= cpu_to_le32(PCL_LAST_BUFF
);
597 reg_set_bits(lynx
, MISC_CONTROL
, MISC_CONTROL_SWRESET
);
598 /* Fix buggy cards with autoboot pin not tied low: */
599 reg_write(lynx
, DMA0_CHAN_CTRL
, 0);
600 reg_write(lynx
, DMA_GLOBAL_REGISTER
, 0x00 << 24);
603 /* now, looking for PHY register set */
604 if ((get_phy_reg(lynx
, 2) & 0xe0) == 0xe0) {
605 lynx
->phyic
.reg_1394a
= 1;
606 PRINT(KERN_INFO
, lynx
->id
,
607 "found 1394a conform PHY (using extended register set)");
608 lynx
->phyic
.vendor
= get_phy_vendorid(lynx
);
609 lynx
->phyic
.product
= get_phy_productid(lynx
);
611 lynx
->phyic
.reg_1394a
= 0;
612 PRINT(KERN_INFO
, lynx
->id
, "found old 1394 PHY");
616 /* Setup the general receive FIFO max size. */
617 reg_write(lynx
, FIFO_SIZES
, 255);
619 reg_set_bits(lynx
, PCI_INT_ENABLE
, PCI_INT_DMA_ALL
);
621 reg_write(lynx
, LINK_INT_ENABLE
,
622 LINK_INT_PHY_TIME_OUT
| LINK_INT_PHY_REG_RCVD
|
623 LINK_INT_PHY_BUSRESET
| LINK_INT_IT_STUCK
|
624 LINK_INT_AT_STUCK
| LINK_INT_SNTRJ
|
625 LINK_INT_TC_ERR
| LINK_INT_GRF_OVER_FLOW
|
626 LINK_INT_ITF_UNDER_FLOW
| LINK_INT_ATF_UNDER_FLOW
);
628 /* Disable the L flag in self ID packets. */
629 set_phy_reg(lynx
, 4, 0);
631 /* Put this baby into snoop mode */
632 reg_set_bits(lynx
, LINK_CONTROL
, LINK_CONTROL_SNOOP_ENABLE
);
634 run_pcl(lynx
, lynx
->rcv_start_pcl_bus
, 0);
636 if (request_irq(dev
->irq
, irq_handler
, IRQF_SHARED
,
637 driver_name
, lynx
)) {
639 "Failed to allocate shared interrupt %d\n", dev
->irq
);
641 goto fail_deallocate_buffers
;
644 lynx
->misc
.parent
= &dev
->dev
;
645 lynx
->misc
.minor
= MISC_DYNAMIC_MINOR
;
646 lynx
->misc
.name
= "nosy";
647 lynx
->misc
.fops
= &nosy_ops
;
649 mutex_lock(&card_mutex
);
650 ret
= misc_register(&lynx
->misc
);
652 dev_err(&dev
->dev
, "Failed to register misc char device\n");
653 mutex_unlock(&card_mutex
);
656 list_add_tail(&lynx
->link
, &card_list
);
657 mutex_unlock(&card_mutex
);
660 "Initialized PCILynx IEEE1394 card, irq=%d\n", dev
->irq
);
665 reg_write(lynx
, PCI_INT_ENABLE
, 0);
666 free_irq(lynx
->pci_device
->irq
, lynx
);
668 fail_deallocate_buffers
:
669 if (lynx
->rcv_start_pcl
)
670 pci_free_consistent(lynx
->pci_device
, sizeof(struct pcl
),
671 lynx
->rcv_start_pcl
, lynx
->rcv_start_pcl_bus
);
673 pci_free_consistent(lynx
->pci_device
, sizeof(struct pcl
),
674 lynx
->rcv_pcl
, lynx
->rcv_pcl_bus
);
675 if (lynx
->rcv_buffer
)
676 pci_free_consistent(lynx
->pci_device
, PAGE_SIZE
,
677 lynx
->rcv_buffer
, lynx
->rcv_buffer_bus
);
678 iounmap(lynx
->registers
);
680 fail_deallocate_lynx
:
684 pci_disable_device(dev
);
689 static struct pci_device_id pci_table
[] = {
691 .vendor
= PCI_VENDOR_ID_TI
,
692 .device
= PCI_DEVICE_ID_TI_PCILYNX
,
693 .subvendor
= PCI_ANY_ID
,
694 .subdevice
= PCI_ANY_ID
,
696 { } /* Terminating entry */
699 MODULE_DEVICE_TABLE(pci
, pci_table
);
701 static struct pci_driver lynx_pci_driver
= {
703 .id_table
= pci_table
,
705 .remove
= remove_card
,
708 module_pci_driver(lynx_pci_driver
);
710 MODULE_AUTHOR("Kristian Hoegsberg");
711 MODULE_DESCRIPTION("Snoop mode driver for TI pcilynx 1394 controllers");
712 MODULE_LICENSE("GPL");