mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 18:14:07 +08:00
27ac792ca0
On 32-bit architectures PAGE_ALIGN() truncates 64-bit values to the 32-bit boundary. For example: u64 val = PAGE_ALIGN(size); always returns a value < 4GB even if size is greater than 4GB. The problem resides in PAGE_MASK definition (from include/asm-x86/page.h for example): #define PAGE_SHIFT 12 #define PAGE_SIZE (_AC(1,UL) << PAGE_SHIFT) #define PAGE_MASK (~(PAGE_SIZE-1)) ... #define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK) The "~" is performed on a 32-bit value, so everything in "and" with PAGE_MASK greater than 4GB will be truncated to the 32-bit boundary. Using the ALIGN() macro seems to be the right way, because it uses typeof(addr) for the mask. Also move the PAGE_ALIGN() definitions out of include/asm-*/page.h in include/linux/mm.h. See also lkml discussion: http://lkml.org/lkml/2008/6/11/237 [akpm@linux-foundation.org: fix drivers/media/video/uvc/uvc_queue.c] [akpm@linux-foundation.org: fix v850] [akpm@linux-foundation.org: fix powerpc] [akpm@linux-foundation.org: fix arm] [akpm@linux-foundation.org: fix mips] [akpm@linux-foundation.org: fix drivers/media/video/pvrusb2/pvrusb2-dvb.c] [akpm@linux-foundation.org: fix drivers/mtd/maps/uclinux.c] [akpm@linux-foundation.org: fix powerpc] Signed-off-by: Andrea Righi <righi.andrea@gmail.com> Cc: <linux-arch@vger.kernel.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
569 lines
13 KiB
C
569 lines
13 KiB
C
/*
|
|
* IEEE 1394 for Linux
|
|
*
|
|
* kernel ISO transmission/reception
|
|
*
|
|
* Copyright (C) 2002 Maas Digital LLC
|
|
*
|
|
* This code is licensed under the GPL. See the file COPYING in the root
|
|
* directory of the kernel sources for details.
|
|
*/
|
|
|
|
#include <linux/pci.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "hosts.h"
|
|
#include "iso.h"
|
|
|
|
/**
|
|
* hpsb_iso_stop - stop DMA
|
|
*/
|
|
void hpsb_iso_stop(struct hpsb_iso *iso)
|
|
{
|
|
if (!(iso->flags & HPSB_ISO_DRIVER_STARTED))
|
|
return;
|
|
|
|
iso->host->driver->isoctl(iso, iso->type == HPSB_ISO_XMIT ?
|
|
XMIT_STOP : RECV_STOP, 0);
|
|
iso->flags &= ~HPSB_ISO_DRIVER_STARTED;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_shutdown - deallocate buffer and DMA context
|
|
*/
|
|
void hpsb_iso_shutdown(struct hpsb_iso *iso)
|
|
{
|
|
if (iso->flags & HPSB_ISO_DRIVER_INIT) {
|
|
hpsb_iso_stop(iso);
|
|
iso->host->driver->isoctl(iso, iso->type == HPSB_ISO_XMIT ?
|
|
XMIT_SHUTDOWN : RECV_SHUTDOWN, 0);
|
|
iso->flags &= ~HPSB_ISO_DRIVER_INIT;
|
|
}
|
|
|
|
dma_region_free(&iso->data_buf);
|
|
kfree(iso);
|
|
}
|
|
|
|
static struct hpsb_iso *hpsb_iso_common_init(struct hpsb_host *host,
|
|
enum hpsb_iso_type type,
|
|
unsigned int data_buf_size,
|
|
unsigned int buf_packets,
|
|
int channel, int dma_mode,
|
|
int irq_interval,
|
|
void (*callback) (struct hpsb_iso
|
|
*))
|
|
{
|
|
struct hpsb_iso *iso;
|
|
int dma_direction;
|
|
|
|
/* make sure driver supports the ISO API */
|
|
if (!host->driver->isoctl) {
|
|
printk(KERN_INFO
|
|
"ieee1394: host driver '%s' does not support the rawiso API\n",
|
|
host->driver->name);
|
|
return NULL;
|
|
}
|
|
|
|
/* sanitize parameters */
|
|
|
|
if (buf_packets < 2)
|
|
buf_packets = 2;
|
|
|
|
if ((dma_mode < HPSB_ISO_DMA_DEFAULT)
|
|
|| (dma_mode > HPSB_ISO_DMA_PACKET_PER_BUFFER))
|
|
dma_mode = HPSB_ISO_DMA_DEFAULT;
|
|
|
|
if ((irq_interval < 0) || (irq_interval > buf_packets / 4))
|
|
irq_interval = buf_packets / 4;
|
|
if (irq_interval == 0) /* really interrupt for each packet */
|
|
irq_interval = 1;
|
|
|
|
if (channel < -1 || channel >= 64)
|
|
return NULL;
|
|
|
|
/* channel = -1 is OK for multi-channel recv but not for xmit */
|
|
if (type == HPSB_ISO_XMIT && channel < 0)
|
|
return NULL;
|
|
|
|
/* allocate and write the struct hpsb_iso */
|
|
|
|
iso =
|
|
kmalloc(sizeof(*iso) +
|
|
buf_packets * sizeof(struct hpsb_iso_packet_info),
|
|
GFP_KERNEL);
|
|
if (!iso)
|
|
return NULL;
|
|
|
|
iso->infos = (struct hpsb_iso_packet_info *)(iso + 1);
|
|
|
|
iso->type = type;
|
|
iso->host = host;
|
|
iso->hostdata = NULL;
|
|
iso->callback = callback;
|
|
init_waitqueue_head(&iso->waitq);
|
|
iso->channel = channel;
|
|
iso->irq_interval = irq_interval;
|
|
iso->dma_mode = dma_mode;
|
|
dma_region_init(&iso->data_buf);
|
|
iso->buf_size = PAGE_ALIGN(data_buf_size);
|
|
iso->buf_packets = buf_packets;
|
|
iso->pkt_dma = 0;
|
|
iso->first_packet = 0;
|
|
spin_lock_init(&iso->lock);
|
|
|
|
if (iso->type == HPSB_ISO_XMIT) {
|
|
iso->n_ready_packets = iso->buf_packets;
|
|
dma_direction = PCI_DMA_TODEVICE;
|
|
} else {
|
|
iso->n_ready_packets = 0;
|
|
dma_direction = PCI_DMA_FROMDEVICE;
|
|
}
|
|
|
|
atomic_set(&iso->overflows, 0);
|
|
iso->bytes_discarded = 0;
|
|
iso->flags = 0;
|
|
iso->prebuffer = 0;
|
|
|
|
/* allocate the packet buffer */
|
|
if (dma_region_alloc
|
|
(&iso->data_buf, iso->buf_size, host->pdev, dma_direction))
|
|
goto err;
|
|
|
|
return iso;
|
|
|
|
err:
|
|
hpsb_iso_shutdown(iso);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_n_ready - returns number of packets ready to send or receive
|
|
*/
|
|
int hpsb_iso_n_ready(struct hpsb_iso *iso)
|
|
{
|
|
unsigned long flags;
|
|
int val;
|
|
|
|
spin_lock_irqsave(&iso->lock, flags);
|
|
val = iso->n_ready_packets;
|
|
spin_unlock_irqrestore(&iso->lock, flags);
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_xmit_init - allocate the buffer and DMA context
|
|
*/
|
|
struct hpsb_iso *hpsb_iso_xmit_init(struct hpsb_host *host,
|
|
unsigned int data_buf_size,
|
|
unsigned int buf_packets,
|
|
int channel,
|
|
int speed,
|
|
int irq_interval,
|
|
void (*callback) (struct hpsb_iso *))
|
|
{
|
|
struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_XMIT,
|
|
data_buf_size, buf_packets,
|
|
channel,
|
|
HPSB_ISO_DMA_DEFAULT,
|
|
irq_interval, callback);
|
|
if (!iso)
|
|
return NULL;
|
|
|
|
iso->speed = speed;
|
|
|
|
/* tell the driver to start working */
|
|
if (host->driver->isoctl(iso, XMIT_INIT, 0))
|
|
goto err;
|
|
|
|
iso->flags |= HPSB_ISO_DRIVER_INIT;
|
|
return iso;
|
|
|
|
err:
|
|
hpsb_iso_shutdown(iso);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_recv_init - allocate the buffer and DMA context
|
|
*
|
|
* Note, if channel = -1, multi-channel receive is enabled.
|
|
*/
|
|
struct hpsb_iso *hpsb_iso_recv_init(struct hpsb_host *host,
|
|
unsigned int data_buf_size,
|
|
unsigned int buf_packets,
|
|
int channel,
|
|
int dma_mode,
|
|
int irq_interval,
|
|
void (*callback) (struct hpsb_iso *))
|
|
{
|
|
struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_RECV,
|
|
data_buf_size, buf_packets,
|
|
channel, dma_mode,
|
|
irq_interval, callback);
|
|
if (!iso)
|
|
return NULL;
|
|
|
|
/* tell the driver to start working */
|
|
if (host->driver->isoctl(iso, RECV_INIT, 0))
|
|
goto err;
|
|
|
|
iso->flags |= HPSB_ISO_DRIVER_INIT;
|
|
return iso;
|
|
|
|
err:
|
|
hpsb_iso_shutdown(iso);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_recv_listen_channel
|
|
*
|
|
* multi-channel only
|
|
*/
|
|
int hpsb_iso_recv_listen_channel(struct hpsb_iso *iso, unsigned char channel)
|
|
{
|
|
if (iso->type != HPSB_ISO_RECV || iso->channel != -1 || channel >= 64)
|
|
return -EINVAL;
|
|
return iso->host->driver->isoctl(iso, RECV_LISTEN_CHANNEL, channel);
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_recv_unlisten_channel
|
|
*
|
|
* multi-channel only
|
|
*/
|
|
int hpsb_iso_recv_unlisten_channel(struct hpsb_iso *iso, unsigned char channel)
|
|
{
|
|
if (iso->type != HPSB_ISO_RECV || iso->channel != -1 || channel >= 64)
|
|
return -EINVAL;
|
|
return iso->host->driver->isoctl(iso, RECV_UNLISTEN_CHANNEL, channel);
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_recv_set_channel_mask
|
|
*
|
|
* multi-channel only
|
|
*/
|
|
int hpsb_iso_recv_set_channel_mask(struct hpsb_iso *iso, u64 mask)
|
|
{
|
|
if (iso->type != HPSB_ISO_RECV || iso->channel != -1)
|
|
return -EINVAL;
|
|
return iso->host->driver->isoctl(iso, RECV_SET_CHANNEL_MASK,
|
|
(unsigned long)&mask);
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_recv_flush - check for arrival of new packets
|
|
*
|
|
* check for arrival of new packets immediately (even if irq_interval
|
|
* has not yet been reached)
|
|
*/
|
|
int hpsb_iso_recv_flush(struct hpsb_iso *iso)
|
|
{
|
|
if (iso->type != HPSB_ISO_RECV)
|
|
return -EINVAL;
|
|
return iso->host->driver->isoctl(iso, RECV_FLUSH, 0);
|
|
}
|
|
|
|
static int do_iso_xmit_start(struct hpsb_iso *iso, int cycle)
|
|
{
|
|
int retval = iso->host->driver->isoctl(iso, XMIT_START, cycle);
|
|
if (retval)
|
|
return retval;
|
|
|
|
iso->flags |= HPSB_ISO_DRIVER_STARTED;
|
|
return retval;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_xmit_start - start DMA
|
|
*/
|
|
int hpsb_iso_xmit_start(struct hpsb_iso *iso, int cycle, int prebuffer)
|
|
{
|
|
if (iso->type != HPSB_ISO_XMIT)
|
|
return -1;
|
|
|
|
if (iso->flags & HPSB_ISO_DRIVER_STARTED)
|
|
return 0;
|
|
|
|
if (cycle < -1)
|
|
cycle = -1;
|
|
else if (cycle >= 8000)
|
|
cycle %= 8000;
|
|
|
|
iso->xmit_cycle = cycle;
|
|
|
|
if (prebuffer < 0)
|
|
prebuffer = iso->buf_packets - 1;
|
|
else if (prebuffer == 0)
|
|
prebuffer = 1;
|
|
|
|
if (prebuffer >= iso->buf_packets)
|
|
prebuffer = iso->buf_packets - 1;
|
|
|
|
iso->prebuffer = prebuffer;
|
|
|
|
/* remember the starting cycle; DMA will commence from xmit_queue_packets()
|
|
once enough packets have been buffered */
|
|
iso->start_cycle = cycle;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_recv_start - start DMA
|
|
*/
|
|
int hpsb_iso_recv_start(struct hpsb_iso *iso, int cycle, int tag_mask, int sync)
|
|
{
|
|
int retval = 0;
|
|
int isoctl_args[3];
|
|
|
|
if (iso->type != HPSB_ISO_RECV)
|
|
return -1;
|
|
|
|
if (iso->flags & HPSB_ISO_DRIVER_STARTED)
|
|
return 0;
|
|
|
|
if (cycle < -1)
|
|
cycle = -1;
|
|
else if (cycle >= 8000)
|
|
cycle %= 8000;
|
|
|
|
isoctl_args[0] = cycle;
|
|
|
|
if (tag_mask < 0)
|
|
/* match all tags */
|
|
tag_mask = 0xF;
|
|
isoctl_args[1] = tag_mask;
|
|
|
|
isoctl_args[2] = sync;
|
|
|
|
retval =
|
|
iso->host->driver->isoctl(iso, RECV_START,
|
|
(unsigned long)&isoctl_args[0]);
|
|
if (retval)
|
|
return retval;
|
|
|
|
iso->flags |= HPSB_ISO_DRIVER_STARTED;
|
|
return retval;
|
|
}
|
|
|
|
/* check to make sure the user has not supplied bogus values of offset/len
|
|
* that would cause the kernel to access memory outside the buffer */
|
|
static int hpsb_iso_check_offset_len(struct hpsb_iso *iso,
|
|
unsigned int offset, unsigned short len,
|
|
unsigned int *out_offset,
|
|
unsigned short *out_len)
|
|
{
|
|
if (offset >= iso->buf_size)
|
|
return -EFAULT;
|
|
|
|
/* make sure the packet does not go beyond the end of the buffer */
|
|
if (offset + len > iso->buf_size)
|
|
return -EFAULT;
|
|
|
|
/* check for wrap-around */
|
|
if (offset + len < offset)
|
|
return -EFAULT;
|
|
|
|
/* now we can trust 'offset' and 'length' */
|
|
*out_offset = offset;
|
|
*out_len = len;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_xmit_queue_packet - queue a packet for transmission.
|
|
*
|
|
* @offset is relative to the beginning of the DMA buffer, where the packet's
|
|
* data payload should already have been placed.
|
|
*/
|
|
int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len,
|
|
u8 tag, u8 sy)
|
|
{
|
|
struct hpsb_iso_packet_info *info;
|
|
unsigned long flags;
|
|
int rv;
|
|
|
|
if (iso->type != HPSB_ISO_XMIT)
|
|
return -EINVAL;
|
|
|
|
/* is there space in the buffer? */
|
|
if (iso->n_ready_packets <= 0) {
|
|
return -EBUSY;
|
|
}
|
|
|
|
info = &iso->infos[iso->first_packet];
|
|
|
|
/* check for bogus offset/length */
|
|
if (hpsb_iso_check_offset_len
|
|
(iso, offset, len, &info->offset, &info->len))
|
|
return -EFAULT;
|
|
|
|
info->tag = tag;
|
|
info->sy = sy;
|
|
|
|
spin_lock_irqsave(&iso->lock, flags);
|
|
|
|
rv = iso->host->driver->isoctl(iso, XMIT_QUEUE, (unsigned long)info);
|
|
if (rv)
|
|
goto out;
|
|
|
|
/* increment cursors */
|
|
iso->first_packet = (iso->first_packet + 1) % iso->buf_packets;
|
|
iso->xmit_cycle = (iso->xmit_cycle + 1) % 8000;
|
|
iso->n_ready_packets--;
|
|
|
|
if (iso->prebuffer != 0) {
|
|
iso->prebuffer--;
|
|
if (iso->prebuffer <= 0) {
|
|
iso->prebuffer = 0;
|
|
rv = do_iso_xmit_start(iso, iso->start_cycle);
|
|
}
|
|
}
|
|
|
|
out:
|
|
spin_unlock_irqrestore(&iso->lock, flags);
|
|
return rv;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_xmit_sync - wait until all queued packets have been transmitted
|
|
*/
|
|
int hpsb_iso_xmit_sync(struct hpsb_iso *iso)
|
|
{
|
|
if (iso->type != HPSB_ISO_XMIT)
|
|
return -EINVAL;
|
|
|
|
return wait_event_interruptible(iso->waitq,
|
|
hpsb_iso_n_ready(iso) ==
|
|
iso->buf_packets);
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_packet_sent
|
|
*
|
|
* Available to low-level drivers.
|
|
*
|
|
* Call after a packet has been transmitted to the bus (interrupt context is
|
|
* OK). @cycle is the _exact_ cycle the packet was sent on. @error should be
|
|
* non-zero if some sort of error occurred when sending the packet.
|
|
*/
|
|
void hpsb_iso_packet_sent(struct hpsb_iso *iso, int cycle, int error)
|
|
{
|
|
unsigned long flags;
|
|
spin_lock_irqsave(&iso->lock, flags);
|
|
|
|
/* predict the cycle of the next packet to be queued */
|
|
|
|
/* jump ahead by the number of packets that are already buffered */
|
|
cycle += iso->buf_packets - iso->n_ready_packets;
|
|
cycle %= 8000;
|
|
|
|
iso->xmit_cycle = cycle;
|
|
iso->n_ready_packets++;
|
|
iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets;
|
|
|
|
if (iso->n_ready_packets == iso->buf_packets || error != 0) {
|
|
/* the buffer has run empty! */
|
|
atomic_inc(&iso->overflows);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&iso->lock, flags);
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_packet_received
|
|
*
|
|
* Available to low-level drivers.
|
|
*
|
|
* Call after a packet has been received (interrupt context is OK).
|
|
*/
|
|
void hpsb_iso_packet_received(struct hpsb_iso *iso, u32 offset, u16 len,
|
|
u16 total_len, u16 cycle, u8 channel, u8 tag,
|
|
u8 sy)
|
|
{
|
|
unsigned long flags;
|
|
spin_lock_irqsave(&iso->lock, flags);
|
|
|
|
if (iso->n_ready_packets == iso->buf_packets) {
|
|
/* overflow! */
|
|
atomic_inc(&iso->overflows);
|
|
/* Record size of this discarded packet */
|
|
iso->bytes_discarded += total_len;
|
|
} else {
|
|
struct hpsb_iso_packet_info *info = &iso->infos[iso->pkt_dma];
|
|
info->offset = offset;
|
|
info->len = len;
|
|
info->total_len = total_len;
|
|
info->cycle = cycle;
|
|
info->channel = channel;
|
|
info->tag = tag;
|
|
info->sy = sy;
|
|
|
|
iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets;
|
|
iso->n_ready_packets++;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&iso->lock, flags);
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_recv_release_packets - release packets, reuse buffer
|
|
*
|
|
* @n_packets have been read out of the buffer, re-use the buffer space
|
|
*/
|
|
int hpsb_iso_recv_release_packets(struct hpsb_iso *iso, unsigned int n_packets)
|
|
{
|
|
unsigned long flags;
|
|
unsigned int i;
|
|
int rv = 0;
|
|
|
|
if (iso->type != HPSB_ISO_RECV)
|
|
return -1;
|
|
|
|
spin_lock_irqsave(&iso->lock, flags);
|
|
for (i = 0; i < n_packets; i++) {
|
|
rv = iso->host->driver->isoctl(iso, RECV_RELEASE,
|
|
(unsigned long)&iso->infos[iso->
|
|
first_packet]);
|
|
if (rv)
|
|
break;
|
|
|
|
iso->first_packet = (iso->first_packet + 1) % iso->buf_packets;
|
|
iso->n_ready_packets--;
|
|
|
|
/* release memory from packets discarded when queue was full */
|
|
if (iso->n_ready_packets == 0) { /* Release only after all prior packets handled */
|
|
if (iso->bytes_discarded != 0) {
|
|
struct hpsb_iso_packet_info inf;
|
|
inf.total_len = iso->bytes_discarded;
|
|
iso->host->driver->isoctl(iso, RECV_RELEASE,
|
|
(unsigned long)&inf);
|
|
iso->bytes_discarded = 0;
|
|
}
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&iso->lock, flags);
|
|
return rv;
|
|
}
|
|
|
|
/**
|
|
* hpsb_iso_wake
|
|
*
|
|
* Available to low-level drivers.
|
|
*
|
|
* Call to wake waiting processes after buffer space has opened up.
|
|
*/
|
|
void hpsb_iso_wake(struct hpsb_iso *iso)
|
|
{
|
|
wake_up_interruptible(&iso->waitq);
|
|
|
|
if (iso->callback)
|
|
iso->callback(iso);
|
|
}
|