/home/hillier_g/checkout/most4linux/most-kernel/most-sync-common.h

Go to the documentation of this file.

/*
 *  Copyright(c) Siemens AG, Muenchen, Germany, 2005, 2006, 2007
 *                           Bernhard Walle <bernhard.walle@gmx.de>
 *                           Gernot Hillier <gernot.hillier@siemens.com>
 *
 * ----------------------------------------------------------------------------
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as 
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * ----------------------------------------------------------------------------
 */
#ifndef MOST_SYNC_COMMON_H
#define MOST_SYNC_COMMON_H

#ifdef HAVE_CONFIG_H
#include "config/config.h"
#endif
#include "most-constants.h"
#include "most-base.h"

struct most_sync_file;


static inline void most_sync_set_sbc_reg(struct most_dev *dev)
{
    unsigned char buf;

    /* locking is not needed because this register doesn't change very often */
    most_readreg8104(dev, &buf, 1, MOST_8104_SBC_REG);
    most_changereg(dev, MOST_PCI_SBC_NPOS_REG, buf - 1, 0xf);
}

#define most_sync_setup_rx_common(param, file, sync_dev, hw_buffer_size,     \
                                  sw_buffer_size, error_var,                 \
                                  most_sync_file_name)                       \
    do {                                                                     \
        struct most_sync_file_name  *entry;                                  \
        int                         number_quadlets;                         \
        unsigned int                dma_size;                                \
        int                         reader_count = 0;                        \
        unsigned int                max_byte     = 0;                        \
        struct list_head            *ptr;                                    \
                                                                             \
        /* enable the interrupt */                                           \
        most_intset(sync_dev->most_dev, IESRX, IESRX, NULL);                 \
                                                                             \
        /* set the state of this device to running */                        \
        file->rx_running = true;                                             \
        file->part_rx = param;                                               \
                                                                             \
        /* get the total number of quadlets */                               \
        max_byte = 0;                                                        \
        list_for_each(ptr, &sync_dev->file_list) {                           \
            entry = list_entry(ptr, struct most_sync_file_name, list);       \
                                                                             \
            if (entry->rx_running) {                                         \
                unsigned int last_byte;                                      \
                                                                             \
                entry->reader_index = reader_count++;                        \
                                                                             \
                last_byte = entry->part_rx.count + entry->part_rx.offset - 1;\
                if (last_byte > max_byte) {                                  \
                    max_byte = last_byte;                                    \
                }                                                            \
            }                                                                \
        }                                                                    \
        number_quadlets = (max_byte + 3) / 4; /* integer ceil */             \
                                                                             \
        /* adjust the number of quadlets */                                  \
        most_writereg(sync_dev->most_dev, number_quadlets - 1,               \
                MOST_PCI_SRXCA_REG);                                         \
        pr_sync_debug(PR "Setting number of qualdets to %d\n",               \
                number_quadlets);                                            \
        most_sync_set_sbc_reg(sync_dev->most_dev);                           \
                                                                             \
        /* set the page size */                                              \
        dma_size = number_quadlets * 4 * 2 * hw_buffer_size;                 \
                                                                             \
        most_writereg(sync_dev->most_dev, dma_size / 2, MOST_PCI_SRXPS_REG); \
        pr_sync_debug(PR "Setting receive page size to %d\n",                \
                dma_size/2);                                                 \
                                                                             \
        /* allocate the DMA buffer if needed */                              \
        if (dma_size > sync_dev->hw_receive_buf.size) {                      \
            if (sync_dev->hw_receive_buf.size != 0) {                        \
                most_dma_deallocate(sync_dev->most_dev,                      \
                        &sync_dev->hw_receive_buf);                          \
            }                                                                \
                                                                             \
            sync_dev->hw_receive_buf.size = dma_size;                        \
            error_var = most_dma_allocate(sync_dev->most_dev,                \
                    &sync_dev->hw_receive_buf);                              \
            if (error_var < 0) {                                             \
                sync_dev->hw_receive_buf.size = 0;                           \
                rtnrt_err(PR "most_dma_allocate failed");                    \
                goto out;                                                    \
            }                                                                \
        }                                                                    \
        pr_sync_debug(PR "Allocated DMA buffer with size %d "                \
                "(Bus: 0x%x)\n", sync_dev->hw_receive_buf.size,              \
                sync_dev->hw_receive_buf.addr_bus);                          \
        pr_measure_debug(PR "==> DMA Buffer RX 0x%X-0x%X <==\n",             \
                sync_dev->hw_receive_buf.addr_bus,                           \
                sync_dev->hw_receive_buf.addr_bus +                          \
                sync_dev->hw_receive_buf.size);                              \
                                                                             \
        memset(sync_dev->hw_receive_buf.addr_virt,                           \
                sync_dev->hw_receive_buf.size, 0);                           \
                                                                             \
        /* set the hardware start address */                                 \
        most_writereg(sync_dev->most_dev, sync_dev->hw_receive_buf.addr_bus, \
                     MOST_PCI_SRXSA_REG);                                    \
                                                                             \
        /* free the old ringbuffer */                                        \
        if (sync_dev->sw_receive_buf) {                                      \
            rxbuf_free(sync_dev->sw_receive_buf);                            \
            sync_dev->sw_receive_buf = NULL;                                 \
        }                                                                    \
                                                                             \
        /* allocate ring buffer */                                           \
        sync_dev->sw_receive_buf = rxbuf_alloc(reader_count, sw_buffer_size, \
                                               number_quadlets * 4);         \
        if (unlikely(!sync_dev->sw_receive_buf)) {                           \
            rtnrt_err(PR "Not enough memory available\n");                   \
            error_var = -ENOMEM;                                             \
            goto out;                                                        \
        }                                                                    \
                                                                             \
        /*                                                                   \
         * ensure that no reordering takes place between setting the         \
         * start bit and configuration bits                                  \
         */                                                                  \
        wmb();                                                               \
                                                                             \
        most_changereg(sync_dev->most_dev, MOST_PCI_SRXCTRL_REG,             \
                SRXST, SRXST);                                               \
        atomic_inc(&sync_dev->receiver_count);                               \
        break;                                                               \
                                                                             \
out:                                                                         \
        /* release the lock for the sync device */                           \
        file->rx_running = false;                                            \
                                                                             \
    } while (0)

#define most_sync_setup_tx_common(param, file, sync_dev, hw_buffer_size,     \
                                  sw_buffer_size, error_var,                 \
                                  most_sync_file_name)                       \
    do {                                                                     \
        struct most_sync_file_name *entry;                                   \
        int                        number_quadlets;                          \
        unsigned int               dma_size;                                 \
        int                        writer_count = 0;                         \
        unsigned int               max_byte     = 0;                         \
        struct list_head           *ptr;                                     \
                                                                             \
        /* enable the interrupt */                                           \
        most_intset(sync_dev->most_dev, IESTX, IESTX, NULL);                 \
                                                                             \
        /* set the state of this device to running */                        \
        file->tx_running = true;                                             \
        file->part_tx = param;                                               \
                                                                             \
        /* get the total number of quadlets */                               \
        max_byte = 0;                                                        \
        list_for_each(ptr, &sync_dev->file_list) {                           \
            entry = list_entry(ptr, struct most_sync_file_name, list);       \
                                                                             \
            if (entry->tx_running) {                                         \
                unsigned int last_byte;                                      \
                                                                             \
                entry->writer_index = writer_count++;                        \
                                                                             \
                last_byte = entry->part_tx.count + entry->part_tx.offset - 1;\
                if (last_byte > max_byte) {                                  \
                    max_byte = last_byte;                                    \
                }                                                            \
            }                                                                \
        }                                                                    \
        number_quadlets = (max_byte + 3) / 4; /* integer ceil */             \
                                                                             \
        /* adjust the number of quadlets */                                  \
        most_writereg(sync_dev->most_dev, number_quadlets - 1,               \
                MOST_PCI_STXCA_REG);                                         \
        pr_sync_debug(PR "Setting number of qualdets to %d\n",               \
                number_quadlets);                                            \
        most_sync_set_sbc_reg(sync_dev->most_dev);                           \
                                                                             \
        /* set the page size */                                              \
        dma_size = number_quadlets * 4 * 2 * hw_buffer_size;                 \
                                                                             \
        most_writereg(sync_dev->most_dev, dma_size / 2, MOST_PCI_STXPS_REG); \
        pr_sync_debug(PR "Setting transmit page size to %d\n",               \
                dma_size/2);                                                 \
                                                                             \
        /* allocate the DMA buffer if needed */                              \
        if (dma_size > sync_dev->hw_transmit_buf.size) {                     \
            if (sync_dev->hw_transmit_buf.size != 0) {                       \
                most_dma_deallocate(sync_dev->most_dev,                      \
                        &sync_dev->hw_transmit_buf);                         \
            }                                                                \
                                                                             \
            sync_dev->hw_transmit_buf.size = dma_size;                       \
            error_var = most_dma_allocate(sync_dev->most_dev,                \
                    &sync_dev->hw_transmit_buf);                             \
            if (error_var < 0) {                                             \
                sync_dev->hw_transmit_buf.size = 0;                          \
                rtnrt_err(PR "most_dma_allocate failed");                    \
                goto out;                                                    \
            }                                                                \
        }                                                                    \
        pr_sync_debug(PR "Allocated DMA buffer with size %d (Bus: 0x%x)\n",  \
                sync_dev->hw_transmit_buf.size,                              \
                sync_dev->hw_receive_buf.addr_bus);                          \
        pr_measure_debug(PR "==> DMA Buffer TX 0x%X-0x%X <==\n",             \
                sync_dev->hw_transmit_buf.addr_bus,                          \
                sync_dev->hw_transmit_buf.addr_bus +                         \
                sync_dev->hw_transmit_buf.size);                             \
                                                                             \
        memset(sync_dev->hw_transmit_buf.addr_virt,                          \
                sync_dev->hw_transmit_buf.size, 0);                          \
                                                                             \
        /* set the hardware start address */                                 \
        most_writereg(sync_dev->most_dev, sync_dev->hw_transmit_buf.addr_bus,\
                      MOST_PCI_STXSA_REG);                                   \
                                                                             \
        /* free the old ringbuffer */                                        \
        if (sync_dev->sw_transmit_buf) {                                     \
            txbuf_free(sync_dev->sw_transmit_buf);                           \
            sync_dev->sw_transmit_buf = NULL;                                \
        }                                                                    \
                                                                             \
        /* allocate ring buffer */                                           \
        sync_dev->sw_transmit_buf = txbuf_alloc(writer_count, sw_buffer_size,\
                                                number_quadlets * 4);        \
        if (unlikely(!sync_dev->sw_transmit_buf)) {                          \
            rtnrt_err(PR "Not enough memory available\n");                   \
            error_var = -ENOMEM;                                             \
            goto out;                                                        \
        }                                                                    \
                                                                             \
        /*                                                                   \
         * ensure that no reordering takes place between setting the         \
         * start bit and configuration bits                                  \
         */                                                                  \
        wmb();                                                               \
                                                                             \
        most_changereg(sync_dev->most_dev, MOST_PCI_STXCTRL_REG,             \
                STXST, STXST);                                               \
        atomic_inc(&sync_dev->transmitter_count);                            \
                                                                             \
        break;                                                               \
                                                                             \
out:                                                                         \
        /* release the lock for the sync device */                           \
        file->tx_running = false;                                            \
                                                                             \
    } while (0)

#define most_sync_stop_rx_common(sync_dev, file)                              \
    do {                                                                      \
        most_intset(sync_dev->most_dev, 0, IESRX, NULL);                      \
        most_changereg(sync_dev->most_dev, MOST_PCI_SRXCTRL_REG, 0, SRXST);   \
        most_intclear(sync_dev->most_dev, ISSRX);                             \
                                                                              \
        file->rx_running = false;                                             \
    } while (0)

#define most_sync_stop_tx_common(sync_dev, file)                              \
    do {                                                                      \
        most_intset(sync_dev->most_dev, 0, IESTX, NULL);                      \
        most_changereg(sync_dev->most_dev, MOST_PCI_STXCTRL_REG, 0, STXST);   \
        most_intclear(sync_dev->most_dev, ISSTX);                             \
                                                                              \
        file->tx_running = false;                                             \
    } while (0)

#define most_sync_last_closed_rx(sync_dev, file, stop_rx)                     \
    do {                                                                      \
        sync_dev->rx_current_page = 0;                                        \
                                                                              \
        stop_rx(file);                                                        \
        rxbuf_free(sync_dev->sw_receive_buf);                                 \
                                                                              \
        /* free the DMA buffers */                                            \
        if (sync_dev->hw_receive_buf.size != 0) {                             \
            most_dma_deallocate(sync_dev->most_dev,                           \
                    &sync_dev->hw_receive_buf);                               \
        }                                                                     \
                                                                              \
        /* mark all as deallocated */                                         \
        sync_dev->sw_receive_buf = NULL;                                      \
        sync_dev->hw_receive_buf.size = 0;                                    \
    } while (0)

#define most_sync_last_closed_tx(sync_dev, file, stop_tx)                     \
    do {                                                                      \
        sync_dev->tx_current_page = 0;                                        \
                                                                              \
        stop_tx(file);                                                        \
        txbuf_free(sync_dev->sw_transmit_buf);                                \
                                                                              \
        /* free the DMA buffer */                                             \
        if (sync_dev->hw_transmit_buf.size != 0) {                            \
            most_dma_deallocate(sync_dev->most_dev,                           \
                    &sync_dev->hw_transmit_buf);                              \
        }                                                                     \
                                                                              \
        /* mark as deallocated */                                             \
        sync_dev->sw_transmit_buf = NULL;                                     \
        sync_dev->hw_transmit_buf.size = 0;                                   \
    } while (0)


extern long sw_rx_buffer_size;

extern long sw_tx_buffer_size;

extern long hw_rx_buffer_size;

extern long hw_tx_buffer_size;

#endif /* MOST_SYNC_COMMON_H */

/* vim: set sw=4 ts=4 et: */

---