Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:juvoram
kernel-n900-2.6.33.3-11.2.armv7l
linux-2.6.34-moorestown-gtm501l-driver-1.2.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File linux-2.6.34-moorestown-gtm501l-driver-1.2.patch of Package kernel-n900-2.6.33.3-11.2.armv7l
Index: linux-2.6.33/drivers/spi/Kconfig =================================================================== --- linux-2.6.33.orig/drivers/spi/Kconfig +++ linux-2.6.33/drivers/spi/Kconfig @@ -335,6 +335,10 @@ config SPI_DW_PCI # comment "SPI Protocol Masters" +config SPI_MRST_GTM501 + tristate "SPI protocol driver for GTM501l" + depends on SPI_MRST + config SPI_SPIDEV tristate "User mode SPI device driver support" depends on EXPERIMENTAL Index: linux-2.6.33/drivers/spi/Makefile =================================================================== --- linux-2.6.33.orig/drivers/spi/Makefile +++ linux-2.6.33/drivers/spi/Makefile @@ -43,6 +43,7 @@ obj-$(CONFIG_SPI_SH_MSIOF) += spi_sh_ms obj-$(CONFIG_SPI_STMP3XXX) += spi_stmp.o obj-$(CONFIG_SPI_NUC900) += spi_nuc900.o obj-$(CONFIG_SPI_MRST) += mrst_spi.o +obj-$(CONFIG_SPI_MRST_GTM501) += gtm501l_spi.o # special build for s3c24xx spi driver with fiq support spi_s3c24xx_hw-y := spi_s3c24xx.o Index: linux-2.6.33/drivers/spi/gtm501l_spi.c =================================================================== --- /dev/null +++ linux-2.6.33/drivers/spi/gtm501l_spi.c @@ -0,0 +1,2029 @@ +/**************************************************************************** + * + * Driver for the Option GTM501L spi modem. + * + * Copyright (C) 2008 Option International + * Copyright (C) 2008 Filip Aben <f.aben@option.com> + * Denis Joseph Barrow <d.barow@option.com> + * Jan Dumon <j.dumon@option.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, + * USA + * + * + * + *****************************************************************************/ + +#include <linux/version.h> +#include <linux/module.h> +#include <linux/tty.h> +#include <linux/device.h> +#include <linux/spi/spi.h> +#include <linux/tty.h> +#include <linux/kfifo.h> +#include <linux/tty_flip.h> +#include <linux/workqueue.h> +#include <linux/timer.h> + +#include <linux/interrupt.h> +#include <linux/irq.h> +#include <linux/rfkill.h> +#include <linux/netdevice.h> +#include <linux/inetdevice.h> +#include <linux/skbuff.h> +#include <net/arp.h> +#include <linux/ip.h> +#include <linux/dmapool.h> +#include <linux/gpio.h> +#include <linux/sysfs.h> + +#include <asm/ipc_defs.h> + +#ifdef CONFIG_DEBUG_FS +#include <linux/debugfs.h> +#include <linux/ktime.h> +#include <linux/spinlock.h> +#endif + +#include "gtm501l_spi.h" +#include <linux/spi/mrst_spi.h> + +/* various static variables */ +static struct tty_driver *tty_drv; +static struct ktermios *gtm501l_termios[GTM501L_MAX_MINORS]; +static struct ktermios *gtm501l_termios_locked[GTM501L_MAX_MINORS]; +static struct lock_class_key gtm501l_key; +static struct gtm501l_port_data *gtm501l_serial_ports[GTM501L_MAX_MINORS]; + +/* Default port spec */ +static struct gtm501l_port_spec gtm501l_default_port_spec[] = { + { 1, GTM501L_PORT_SPEC_SERIAL, "Control" }, /* 0 */ + { 1, GTM501L_PORT_SPEC_SERIAL, "NetAT" }, /* 1 */ + { 1, GTM501L_PORT_SPEC_NET, "NetIP" }, /* 2 */ + { 1, GTM501L_PORT_SPEC_SERIAL, "App" }, /* 3 */ + { 1, GTM501L_PORT_SPEC_SERIAL, "App2" }, /* 4 */ + { 1, GTM501L_PORT_SPEC_SERIAL, "PC/SC" }, /* 5 */ + { 1, GTM501L_PORT_SPEC_SERIAL, "Modem" }, /* 6 */ + { 1, GTM501L_PORT_SPEC_SERIAL, "Diag" }, /* 7 */ + { 1, GTM501L_PORT_SPEC_SERIAL, "Logger" }, /* 8 */ + { 0, GTM501L_PORT_SPEC_SERIAL, "" }, /* 9 */ + { 1, GTM501L_PORT_SPEC_NET, "NetIP2" }, /* 10 */ + { 0, GTM501L_PORT_SPEC_SERIAL, "" }, /* 11 */ + { 0, GTM501L_PORT_SPEC_SERIAL, "" }, /* 12 */ + { 0, GTM501L_PORT_SPEC_SERIAL, "" }, /* 13 */ + { 0, GTM501L_PORT_SPEC_SERIAL, "" }, /* 14 */ + { 0, GTM501L_PORT_SPEC_SERIAL, "" }, /* 15 */ +}; + +/* Module load parameter */ +static int gpio_in = -1; /* GPIO interrupt input assignment, set default to -1 */ +static int backoff_enabled = 1; /* Enable the backoff timer */ +static int spi_b16 = 1; /* Enable 16bit SPI word length, otherwise use 8bit SPI word length */ +int gtm501l_debug = 0; + +/* temp debug variables */ +static int spi_err_count = 0; +static unsigned int total_tty_write = 0; +static unsigned int total_spi_write = 0; + +static unsigned char scratch_buf[GTM501L_TRANSFER_SIZE]; + +static int reset_state = 1; + +/* prototype declarations */ +static void gtm501l_push_skb(struct gtm501l_port_data *port_data); +static void gtm501l_net_init(struct net_device *net); +static void gtm501l_spi_complete(void *ctx); +static void _gtm501l_set_termios(struct tty_struct *tty, struct ktermios *old); +static void gtm501l_throttle(struct tty_struct *tty); +static void gtm501l_create_ports(struct gtm501l_device *gtm_dev, + struct gtm501l_port_spec *specs); +/*static void gtm501l_pmic_init_voltages( void );*/ +static void gtm501l_pmic_set_wwanresetn( unsigned char level ); +static void gtm501l_pmic_set_wwandisablen( unsigned char level ); + +void gtm501l_debug_printk(const char *function, int line, char *format, ...) { + va_list args; + int len; + char buffer[255]; + + len = snprintf(buffer, 255, DRVNAME " [%s:%d] ", function, line); + + va_start(args, format); + vsnprintf(buffer + len, 255 - len, format, args); + va_end(args); + + printk("%s", buffer); +} + +#define __bswap_16(x) \ + (__extension__ \ + ({ register unsigned short int __v, __x = (x); \ + __asm__ ("rorw $8, %w0" \ + : "=r" (__v) \ + : "0" (__x) \ + : "cc"); \ + __v; })) + +static inline void swap_buf(u16 *buf, int len) { + int n; + len = (len + 1) / 2; + n = (len + 7) / 8; + switch (len % 8) { + case 0: do { *buf = __bswap_16(*buf); buf++; + case 7: *buf = __bswap_16(*buf); buf++; + case 6: *buf = __bswap_16(*buf); buf++; + case 5: *buf = __bswap_16(*buf); buf++; + case 4: *buf = __bswap_16(*buf); buf++; + case 3: *buf = __bswap_16(*buf); buf++; + case 2: *buf = __bswap_16(*buf); buf++; + case 1: *buf = __bswap_16(*buf); buf++; + } while (--n > 0); + } +} + +#ifdef CONFIG_DEBUG_FS + +static ssize_t gtm501l_read_gpio(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) +{ + char buf[32]; + unsigned int len = 0; + if (gpio_in >= 0) { + len += snprintf(buf+len, sizeof(buf)-len, + "GPIO%d = %d\n", gpio_in, (gpio_get_value(gpio_in))?1:0); + } else { + len += snprintf(buf+len, sizeof(buf)-len, + "GPIO unuse\n"); + } + return simple_read_from_buffer(user_buf, count, ppos, buf, len); +} + +static struct file_operations gtm501l_gpio_operations = { + .owner = THIS_MODULE, + .read = gtm501l_read_gpio, +}; + +static ssize_t gtm501l_read_pmic(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) +{ + char buf[8]; + unsigned int len = sprintf(buf, "%d\n", reset_state); + + return simple_read_from_buffer(user_buf, count, ppos, buf, len); +} + +static ssize_t gtm501l_write_pmic(struct file *file, const char __user *user, size_t count, loff_t *offset) +{ + reset_state = simple_strtoul(user, NULL, 0); + gtm501l_pmic_set_wwanresetn( reset_state ); + gtm501l_pmic_set_wwandisablen( reset_state ); + return count; +} + +static struct file_operations gtm501l_pmic_operations = { + .owner = THIS_MODULE, + .read = gtm501l_read_pmic, + .write = gtm501l_write_pmic, +}; + +/** + * gtm501l_debugfs_init generates all debugfs file nodes. + * It initialized the frame statistic structure. + */ +static int gtm501l_debugfs_init(struct gtm501l_device *gtm_dev) +{ + gtm_dev->debugfs = debugfs_create_dir("gtm501l", NULL); + if (!gtm_dev->debugfs) + return -ENOMEM; + + debugfs_create_file("gpio", S_IFREG | S_IRUGO, + gtm_dev->debugfs, NULL, >m501l_gpio_operations); + debugfs_create_file("pmic", S_IFREG | S_IRUGO, + gtm_dev->debugfs, NULL, >m501l_pmic_operations); + debugfs_create_u32("backoff_timer", S_IFREG | S_IRUGO, + gtm_dev->debugfs, &backoff_enabled); + debugfs_create_x32("flags", S_IFREG | S_IRUGO, + gtm_dev->debugfs, (unsigned int *)>m_dev->flags); +#ifdef DEBUG + debugfs_create_x32("debug", S_IFREG | S_IRUGO, + gtm_dev->debugfs, >m501l_debug); +#endif + + return 0; +} + +static void gtm501l_debugfs_remove(struct gtm501l_device *gtm_dev) +{ + if (gtm_dev->debugfs) + debugfs_remove_recursive(gtm_dev->debugfs); +} +#endif + +static __be32 gtm501l_get_ip_addr(struct net_device *net) +{ + struct in_device *in_dev; + + if ((in_dev = __in_dev_get_rtnl(net)) != NULL) { + if(in_dev->ifa_list) { + return in_dev->ifa_list->ifa_local; + } + } + + return 0; +} + +/* +static void gtm501l_pmic_init_voltages( void ) +{ + struct ipc_pmic_reg_data reg_data; + + reg_data.num_entries = 3; + + // Set VDDQCNT + + reg_data.pmic_reg_data[0].register_address = 0x037; + reg_data.pmic_reg_data[0].value = 0x07; + + // Set YMX3GDCNT + + reg_data.pmic_reg_data[1].register_address = 0x03c; + reg_data.pmic_reg_data[1].value = 0x47; + + // Set CLKOUT + + reg_data.pmic_reg_data[2].register_address = 0x021; + reg_data.pmic_reg_data[2].value = 0x00; + ipc_pmic_register_write(®_data, 0); + +} +*/ + +static void gtm501l_pmic_set_wwanresetn( unsigned char level ) +{ + struct ipc_pmic_mod_reg_data mod_reg_data; + + // WWAN_RESET_N is connected to COMMS_GPO5 + + mod_reg_data.num_entries = 1; + mod_reg_data.pmic_mod_reg_data[0].bit_map = 0x20; + mod_reg_data.pmic_mod_reg_data[0].register_address = 0x0f4; + + if (level) + { + mod_reg_data.pmic_mod_reg_data[0].value = 0x20; + } + else + { + mod_reg_data.pmic_mod_reg_data[0].value = 0x00; + } + + ipc_pmic_register_read_modify(&mod_reg_data); +} + +static void gtm501l_pmic_set_wwandisablen( unsigned char level ) +{ + struct ipc_pmic_mod_reg_data mod_reg_data; + + // WWAN_DISABLE_N is connected to COMMS_GPO0 + + mod_reg_data.num_entries = 1; + mod_reg_data.pmic_mod_reg_data[0].bit_map = 0x01; + mod_reg_data.pmic_mod_reg_data[0].register_address = 0x0f4; + + if (level) + { + mod_reg_data.pmic_mod_reg_data[0].value = 0x01; + } + else + { + mod_reg_data.pmic_mod_reg_data[0].value = 0x00; + } + + ipc_pmic_register_read_modify(&mod_reg_data); +} + + +static void gtm501l_rx_netchar(struct gtm501l_net *gtm_net, + unsigned char *in_buf, int size) +{ + struct net_device *net = gtm_net->net; + unsigned int temp_bytes; + unsigned int buffer_offset = 0, n; + unsigned int frame_len; + unsigned char *tmp_rx_buf; + unsigned char c; + int header_invalid; + + while(size) { + switch (gtm_net->rx_state) { + case WAIT_IP: + /* waiting for IP header. */ + /* wanted bytes - size of ip header */ + temp_bytes = (size < gtm_net->rx_buf_missing) ? + size : gtm_net->rx_buf_missing; + + memcpy(((unsigned char *)(>m_net->rx_ip_hdr)) + + gtm_net->rx_buf_size, in_buf + buffer_offset, + temp_bytes); + + gtm_net->rx_buf_size += temp_bytes; + buffer_offset += temp_bytes; + gtm_net->rx_buf_missing -= temp_bytes; + size -= temp_bytes; + + if (!gtm_net->rx_buf_missing) { + /* header is complete allocate an sk_buffer and + * continue to WAIT_DATA */ + + header_invalid = 0; + + frame_len = ntohs(gtm_net->rx_ip_hdr.tot_len); + if ((frame_len > GTM501L_DEFAULT_MRU) || + (frame_len < sizeof(struct iphdr))) { + if(!gtm_net->sync_lost) + dev_err(&net->dev, + "Invalid frame length (%d)\n", + frame_len); + header_invalid = 1; + } + + /* Validate destination address */ + if (!header_invalid && + (gtm501l_get_ip_addr(net) != gtm_net->rx_ip_hdr.daddr)) { + if(!gtm_net->sync_lost) + dev_err(&net->dev, + "Not our address (" NIPQUAD_FMT ")\n", + NIPQUAD(gtm_net->rx_ip_hdr.daddr)); + header_invalid = 1; + } + + if (header_invalid) { + /* This header is not valid, roll back + * for sizeof(header) bytes - 1 and + * wait for sync */ + gtm_net->rx_state = WAIT_SYNC; + n = min(buffer_offset, + sizeof(struct iphdr) - 1); + buffer_offset -= n; + size += n; + continue; + } + + /* Allocate an sk_buff */ + gtm_net->rx_skb = dev_alloc_skb(frame_len); + if (!gtm_net->rx_skb) { + /* We got no receive buffer. */ + //D1("ddcould not allocate memory"); + gtm_net->rx_state = WAIT_SYNC; + return; + } + + if(gtm_net->sync_lost) { + dev_info(&net->dev, "Back in sync. (%d stray bytes)\n", + gtm_net->sync_lost); + gtm_net->sync_lost = 0; + } + + /* Here's where it came from */ + gtm_net->rx_skb->dev = net; + + /* Copy what we got so far. make room for iphdr + * after tail. */ + tmp_rx_buf = + skb_put(gtm_net->rx_skb, + sizeof(struct iphdr)); + memcpy(tmp_rx_buf, (char *)&(gtm_net->rx_ip_hdr), + sizeof(struct iphdr)); + + /* ETH_HLEN */ + gtm_net->rx_buf_size = sizeof(struct iphdr); + + gtm_net->rx_buf_missing = + frame_len - sizeof(struct iphdr); + gtm_net->rx_state = WAIT_DATA; + } + break; + + case WAIT_DATA: + temp_bytes = (size < gtm_net->rx_buf_missing) + ? size : gtm_net->rx_buf_missing; + + /* Copy the rest of the bytes that are left in the + * buffer into the waiting sk_buf. */ + /* Make room for temp_bytes after tail. */ + tmp_rx_buf = skb_put(gtm_net->rx_skb, temp_bytes); + memcpy(tmp_rx_buf, in_buf + buffer_offset, temp_bytes); + + gtm_net->rx_buf_missing -= temp_bytes; + size -= temp_bytes; + buffer_offset += temp_bytes; + gtm_net->rx_buf_size += temp_bytes; + if (!gtm_net->rx_buf_missing) { + /* Packet is complete. Inject into stack. */ + /* We have IP packet here */ + gtm_net->rx_skb->protocol = + __constant_htons(ETH_P_IP); + /* don't check it */ + gtm_net->rx_skb->ip_summed = + CHECKSUM_UNNECESSARY; + + skb_reset_mac_header(gtm_net->rx_skb); + + /* Ship it off to the kernel */ + netif_rx(gtm_net->rx_skb); + /* No longer our buffer. */ + gtm_net->rx_skb = NULL; + + /* update out statistics */ + STATS(net).rx_packets++; + STATS(net).rx_bytes += gtm_net->rx_buf_size; + + gtm_net->rx_buf_size = 0; + gtm_net->rx_buf_missing = sizeof(struct iphdr); + gtm_net->rx_state = WAIT_IP; + } + break; + + case WAIT_SYNC: + if(!gtm_net->sync_lost) { + dev_err(&net->dev, "Lost sync...\n"); + } + gtm_net->sync_lost++; + /* Look for the next possible IP header */ + c = *(in_buf + buffer_offset); + if(c >= 0x45 && c <= 0x4f) { + /* This might be the begin of a new ip pkt */ + gtm_net->rx_state = WAIT_IP; + gtm_net->rx_buf_size = 0; + gtm_net->rx_buf_missing = sizeof(struct iphdr); + } + else { + size--; + buffer_offset++; + } + break; + + default: + size--; + break; + } + } +} + +/* mux functions */ + +/* function that tells you how much characters you can feed to fill your mux buffer*/ +static inline int gtm501l_mux_to_demux(int count) +{ + int burst_cnt, remain_cnt; + if (count & 0x1) { + printk("Error - space in frame can't be an odd number\n"); + return -1; + } + /* We've got 2 extra bytes of framing per 512 bytes of data */ + burst_cnt = (count / (MUX_BURST_SIZE + 2)) * MUX_BURST_SIZE; + remain_cnt = count % (MUX_BURST_SIZE + 2); + + if (remain_cnt > 2) + return remain_cnt - 2 + burst_cnt; + else + return burst_cnt + 1; +} + +/* multiplexes the data into the output buffer. output buffer is expected to be large enough to fit the data. */ +static int gtm501l_mux_data(int chan_id, unsigned char *in_buf, int in_size, + unsigned char *out_buf) +{ + int odd, cnt, result_size = 0; + + /* check for an odd number of bytes */ + odd = in_size & 0x1; + + /* make it even */ + in_size &= ~1; + + /* First fill up with as much burst frames as possible */ + while (in_size) { + + cnt = (in_size >= MUX_BURST_SIZE) ? MUX_BURST_SIZE : in_size; + *(out_buf + result_size) = + MUX_CONTROL_BYTE(chan_id, MUX_BURST_TRANSFER, + MUX_MASTER_TO_SLAVE); + //printk("Burst frame %d bytes\n", cnt); + result_size++; + *(out_buf + result_size) = cnt / 2; + result_size++; + memcpy(out_buf + result_size, in_buf, cnt); + result_size += cnt; + in_size -= cnt; + in_buf += cnt; + } + + /* Then tackle the odd byte */ + if (odd) { + *(out_buf + result_size) = + MUX_CONTROL_BYTE(chan_id, MUX_DATA_TRANSFER, + MUX_MASTER_TO_SLAVE); + result_size++; + *(out_buf + result_size) = *in_buf; + result_size++; + + } + + return result_size; +} + +/* kfifo put theoretically cannot fail to copy all buffer here */ +void gtm501l_tty_insert_flip_string(struct gtm501l_serial *gtm_ser, + unsigned char *chars,size_t size) +{ + int chars_inserted; + int copylen; + struct tty_struct *tty; + + if (gtm_ser && gtm_ser->tty) { + tty= gtm_ser->tty; + if (test_bit(TTY_THROTTLED, &tty->flags)) { + dprintk(DEBUG_TTY, "received %d bytes while throttled\n", size); + copylen=kfifo_in(gtm_ser->throttle_fifo,chars,size); + if(copylen!=size) + dprintk(DEBUG_TTY, "kfifo_put failed got %d expected %d\n", + copylen, size); + } + else { + chars_inserted=tty_insert_flip_string(tty, chars, size); + if(chars_inserted!=size) { + + size -= chars_inserted; + copylen=kfifo_in(gtm_ser->throttle_fifo, + &chars[chars_inserted], + size); + if(copylen!=size) + dprintk(DEBUG_TTY, "%s kfifo_put failed got %d expected %d\n", + copylen, size); + } + /* The flip here should force the tty layer + * to throttle if neccessary + */ + tty_flip_buffer_push(tty); + } + } + +} + +#define PORT_SPEC_FLAGS_ENABLED 0x80 +#define PORT_SPEC_FLAGS_TYPE_MASK 0x7f +#define PORT_SPEC_FLAGS_SERIAL 0x01 +#define PORT_SPEC_FLAGS_NET 0x02 + +static void gtm501l_decode_version_info(struct gtm501l_device *gtm_dev, + unsigned char *buf, int size) +{ + int i = 0, chan, flags; + u16 version; + u16 framelength; + struct gtm501l_port_spec *new_port_spec; + + /* Protocol version */ + memcpy(&version, buf + i, 2); + i += 2; + + if(version != 0 || size != 260) { + /* Unknown version or size is wrong.. */ + return; + } + + /* Frame length */ + memcpy(&framelength, buf + i, 2); + i += 2; + + /* Channel descriptors */ + new_port_spec = kzalloc(sizeof(struct gtm501l_port_spec) * 16, GFP_KERNEL); + for(chan = 0; chan < 16; chan++) { + flags = buf[i++]; + + if(flags | PORT_SPEC_FLAGS_ENABLED) { + new_port_spec[chan].enabled = 1; + switch(flags & PORT_SPEC_FLAGS_TYPE_MASK) { + case PORT_SPEC_FLAGS_SERIAL: + new_port_spec[chan].type = GTM501L_PORT_SPEC_SERIAL; + break; + case PORT_SPEC_FLAGS_NET: + new_port_spec[chan].type = GTM501L_PORT_SPEC_NET; + break; + default: + /* Unknown channel type: disable this channel */ + new_port_spec[chan].enabled = 0; + } + + /* Copy the name */ + memcpy(&new_port_spec[chan].name, buf + i, 15); + } + + i += 15; + } + + /* Activate the new port spec */ + gtm501l_create_ports(gtm_dev, new_port_spec); + kfree(new_port_spec); +} + + +/** + * gtm501l_demux walks through the received SPI message given in in_buf with the length size and copies all + * found data into the opened channels given in the gtm_dev structure. The SPI buffer length must be always + * a multiple of 2 bytes! + * It returns finally the real found useful data inside the SPI frame length + */ +static int gtm501l_demux(struct gtm501l_device *gtm_dev, unsigned char *in_buf, + int size) +{ + int i = 0, valid = 0, copy; + unsigned char temp; + struct gtm501l_port_data *port_data; + struct gtm501l_serial *gtm_ser = NULL; + struct gtm501l_net *gtm_net = NULL; + unsigned char old_dcd; + + gtm_dev->empty_transfers++; + + while (i < size) { + gtm_ser = NULL; + gtm_net = NULL; + copy = 0; + + if(spi_b16) + swap_buf((u16 *)(in_buf + i), 2); + + /* check for an end of frame sequence */ + if((in_buf[i]==0) && (in_buf[i+1]==0)) break; + + if(0 && in_buf[i] == 0xFF) { /* TODO: Fill in correct check for version info */ + copy = in_buf[++i] * 2; + i++; + if(spi_b16) + swap_buf((u16 *)(in_buf + i), copy); + gtm501l_decode_version_info(gtm_dev, in_buf + i, copy); + i += copy; + continue; + } + + /* verify valid packet */ + temp = MUX_DEVICE(in_buf[i]); + if (temp != MUX_SLAVE_TO_MASTER) { + /* + * ##PH: That should never happen and should counted as errorness data + */ + i += 2; + continue; + } + +#ifdef DEBUG + if(!valid && (i > 0) && (gtm501l_debug & DEBUG_DEMUX)) { + int j; + dprintk(DEBUG_DEMUX, "First valid byte found at offset %d\n", i); + for(j=0 ; j<i ; j++) printk("%.2X ", in_buf[j]); + printk("\n"); + } +#endif + + valid = 1; + + //dprintk(DEBUG_DEMUX, "Got valid mux bytes 0x%X 0x%X\n", in_buf[i], in_buf[i+1]); + + /* verify valid channel */ + temp = MUX_CHANNEL(in_buf[i]); + if (temp >= GTM501L_PORT_PER_DEV || !gtm_dev->port_data[temp]) { + i += 2; + continue; + } + port_data = gtm_dev->port_data[temp]; + + if (port_data->spec.type == GTM501L_PORT_SPEC_NET) + gtm_net = &port_data->type.net; + else if (port_data->spec.type == GTM501L_PORT_SPEC_SERIAL) + gtm_ser = &port_data->type.serial; + //dprintk(DEBUG_DEMUX, "For channel %d\n", temp); + + /* start decoding data */ + temp = MUX_BLOCK_TYPE(in_buf[i]); + if (temp == MUX_BURST_TRANSFER) { + copy = in_buf[++i] * 2; + if( 0 == copy ) copy = MUX_BURST_SIZE; + if(spi_b16) + swap_buf((u16 *)(in_buf + i + 1), copy); + } else if (temp == MUX_DATA_TRANSFER) { + copy = 1; + } + + if (copy) { + gtm_dev->empty_transfers = 0; + //dprintk(DEBUG_DEMUX, "\tNeed to copy %d data bytes\n", copy); + /* regular data */ + if( gtm_ser && gtm_ser->tty ) { + gtm501l_tty_insert_flip_string(gtm_ser, &in_buf[++i], copy); + } + else if (gtm_net) { +/* + int j; + for(j=i+1;j<(i+1+copy);j++) printk("0x%.2X ", in_buf[j]); + printk("\n"); +*/ + gtm501l_rx_netchar(gtm_net, &in_buf[++i], copy); + } else { + i++; + } + + i += copy; + continue; + } + + if (temp == MUX_CONTROL_TRANSFER) { + //dprintk(DEBUG_DEMUX, "Is a control byte\n"); + /* control data */ + temp = in_buf[i + 1]; + if (MUX_LINK(temp)) { + set_bit(GTM501L_TX_FC, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "FC set\n"); + } else { + clear_bit(GTM501L_TX_FC, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "FC cleared\n"); + } + + if (gtm_ser) { + old_dcd = + test_bit(GTM501L_DCD, + &port_data->signal_state); + + if (MUX_DCD(temp)) { + set_bit(GTM501L_DCD, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "DCD set\n"); + } else { + clear_bit(GTM501L_DCD, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "DCD cleared\n"); + } + if (MUX_CTS(temp)) { + set_bit(GTM501L_CTS, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "CTS set\n"); + } else { + clear_bit(GTM501L_CTS, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "CTS cleared\n"); + } + + if (MUX_DSR(temp)) { + set_bit(GTM501L_DSR, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "DSR set\n"); + } else { + clear_bit(GTM501L_DSR, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "DSR cleared\n"); + } + + if (MUX_RI(temp)) { + set_bit(GTM501L_RI, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "RI set\n"); + } else { + clear_bit(GTM501L_RI, + &port_data->signal_state); + dprintk(DEBUG_DEMUX, "RI cleared\n"); + } + + if (old_dcd + && !test_bit(GTM501L_DCD, + &port_data->signal_state)) + if (gtm_ser->tty) + tty_hangup(gtm_ser->tty); + } + + i += 2; + } + + } + return i; +} + +static int gtm501l_mux_flow_control(struct gtm501l_port_data *port_data, + unsigned char *out_buf) +{ + *out_buf = + MUX_CONTROL_BYTE(port_data->port_id, MUX_CONTROL_TRANSFER, + MUX_MASTER_TO_SLAVE); + *(out_buf + 1) = + (test_bit(GTM501L_DTR, &port_data->signal_state) + ? (1 << MUX_DTR_SHIFT) : 0) + | (test_bit(GTM501L_RTS, &port_data->signal_state) + ? (1 << MUX_RTS_SHIFT): 0) + | (test_bit(GTM501L_RX_FC, &port_data->signal_state) + ? (1 << MUX_LINK_SHIFT): 0); + + return 2; +} + +static void gtm501l_timer(unsigned long arg) +{ + struct tasklet_struct *tasklet = (struct tasklet_struct *)arg; + //printk("Timer fired\n"); + tasklet_hi_schedule(tasklet); +} + +/* gpio interrupt handler */ + +static irqreturn_t gtm501l_gpio_interrupt(int irq, void *dev) +{ + struct gtm501l_device *gtm_dev = (struct gtm501l_device *)dev; + static int count = 0; + + if(!gtm_dev || !test_bit(GTM501L_STATE_PRESENT, >m_dev->flags)) + return IRQ_HANDLED; + + /* + * Using the GPE layer it will set the + * irq to the requested gpio_in line + */ + + if(gtm_dev->stats) gtm_dev->stats->wait_finished(gtm_dev->frame_stats); + + if (!(count % 5000)) + dprintk(DEBUG_GPIO, "Scheduling\n"); + + if(!test_bit(GTM501L_STATE_IO_IN_PROGRESS, >m_dev->flags)) { + + /* If we received no data for the last x + * frames, delay the next transfer */ + if(gtm_dev->empty_transfers > GTM501L_MAX_EMPTY && backoff_enabled) { + if(!timer_pending(>m_dev->timer)) { + gtm_dev->timer.expires = jiffies + GTM501L_BACKOFF_TIMER; + gtm_dev->timer.function = gtm501l_timer; + gtm_dev->timer.data = (unsigned long)>m_dev->io_work_tasklet; + add_timer(>m_dev->timer); + } + } + else + tasklet_hi_schedule(>m_dev->io_work_tasklet); + } + else set_bit(GTM501L_STATE_IO_READY, >m_dev->flags); + + count++; + + return IRQ_HANDLED; +} + +static int gtm501l_prepare_tx_buffer(struct gtm501l_device *gtm_dev) +{ + int tx_count = 0; + int i, j; + unsigned int temp_count; + struct gtm501l_port_data *port_data; + int round_robin_index; + unsigned char *tx_buffer; + int len; + + if(gtm_dev->stats) gtm_dev->stats->encode_start_idle_finished(gtm_dev->frame_stats); + + tx_buffer = gtm_dev->tx_buffer[gtm_dev->tx_buffer_used]; + + /* First add flow control events for all ports */ + for (i = 0; i < GTM501L_PORT_PER_DEV; i++) { + port_data = gtm_dev->port_data[i]; + if(!port_data) + continue; + + if (test_and_clear_bit (GTM501L_UPDATE, &port_data->signal_state)) { + tx_count += gtm501l_mux_flow_control(port_data, + tx_buffer + tx_count); + } + } + + /* assemble data from buffers from all ports */ + round_robin_index = gtm_dev->round_robin_index; + for (j = round_robin_index; j < + (GTM501L_PORT_PER_DEV + round_robin_index) ; j++) { + i = j % GTM501L_PORT_PER_DEV; + port_data = gtm_dev->port_data[i]; + if(!port_data) + continue; + + /* check if this port is flow controlled */ + if (test_bit(GTM501L_TX_FC, &port_data->signal_state)) + continue; + + /* check for data to be sent */ + temp_count = gtm501l_mux_to_demux(GTM501L_TRANSFER_SIZE - tx_count); + temp_count = min(kfifo_len(port_data->tx_fifo), temp_count); + if (temp_count) { + len = kfifo_out(port_data->tx_fifo, scratch_buf, temp_count); +#ifdef GTM501L_DEBUG + sprintf(debug_buff_name, "gtm501l tx buf port %d %d", i, len); + GTM501L_BUFFER_DUMP(debug_buff_name, scratch_buf, temp_count); +#endif + tx_count += gtm501l_mux_data(i, scratch_buf, temp_count, + tx_buffer + tx_count); + total_spi_write += temp_count; + gtm_dev->empty_transfers = 0; + } + if( port_data->spec.type == GTM501L_PORT_SPEC_NET) + gtm501l_push_skb(port_data); + else if(port_data->type.serial.tty) + tty_wakeup(port_data->type.serial.tty); + } + gtm_dev->round_robin_index = gtm_dev->round_robin_index + 1; + if (gtm_dev->round_robin_index == GTM501L_PORT_PER_DEV) + gtm_dev->round_robin_index = 0; + + /* End-Of-Frame marker */ + temp_count = min(2, GTM501L_TRANSFER_SIZE - tx_count); + memset(tx_buffer + tx_count, 0, temp_count); + tx_count += temp_count; + + if(spi_b16) + swap_buf((u16 *)(tx_buffer), tx_count); + + gtm_dev->tx_count = tx_count; + + if(gtm_dev->stats) gtm_dev->stats->encode_finished(gtm_dev->frame_stats, tx_count - temp_count); + + return tx_count; +} + +/* serial functions */ +static void gtm501l_io(unsigned long data) +{ + struct gtm501l_device *gtm_dev = (struct gtm501l_device *)data; + int retval; +#ifdef GTM501L_DEBUG + char debug_buff_name[80]; +#endif + + if (!test_bit(GTM501L_STATE_PRESENT, >m_dev->flags)) + return; + + if (!test_and_set_bit(GTM501L_STATE_IO_IN_PROGRESS, >m_dev->flags)) { + gtm501l_prepare_tx_buffer(gtm_dev); + + if(gtm_dev->stats) gtm_dev->stats->transfer_start(gtm_dev->frame_stats); + + spi_message_init(>m_dev->spi_msg); + gtm_dev->spi_msg.context = gtm_dev; + gtm_dev->spi_msg.complete = gtm501l_spi_complete; + gtm_dev->spi_msg.is_dma_mapped = 1; + + /* set up our spi transfer */ + gtm_dev->spi_xfer.len = GTM501L_TRANSFER_SIZE; + gtm_dev->spi_xfer.cs_change = 0; +#if 0 + gtm_dev->tx_dma[gtm_dev->tx_buffer_used] = + dma_map_single(>m_dev->spi_dev->dev, gtm_dev->tx_buffer[gtm_dev->tx_buffer_used], + GTM501L_TRANSFER_SIZE, DMA_TO_DEVICE); + gtm_dev->rx_dma = dma_map_single(>m_dev->spi_dev->dev, gtm_dev->rx_buffer, + GTM501L_TRANSFER_SIZE, DMA_FROM_DEVICE); +#else + gtm_dev->tx_dma[gtm_dev->tx_buffer_used] = virt_to_phys(gtm_dev->tx_buffer[gtm_dev->tx_buffer_used]); + gtm_dev->rx_dma = virt_to_phys(gtm_dev->rx_buffer); +#endif + + gtm_dev->spi_xfer.tx_dma = gtm_dev->tx_dma[gtm_dev->tx_buffer_used]; + gtm_dev->spi_xfer.tx_buf = gtm_dev->tx_buffer[gtm_dev->tx_buffer_used]; + gtm_dev->tx_buffer_used = (++gtm_dev->tx_buffer_used) % 2; + gtm_dev->tx_count = 0; + + gtm_dev->spi_xfer.rx_dma = gtm_dev->rx_dma; + gtm_dev->spi_xfer.rx_buf = gtm_dev->rx_buffer; + + spi_message_add_tail(>m_dev->spi_xfer, >m_dev->spi_msg); + + retval = spi_async(gtm_dev->spi_dev, >m_dev->spi_msg); + + if (retval) { + dprintk(DEBUG_SPI, "ERROR: spi_async failed (%d)\n", retval); + clear_bit(GTM501L_STATE_IO_IN_PROGRESS, + >m_dev->flags); + tasklet_hi_schedule(>m_dev->io_work_tasklet); + return; + } + } else { + dprintk(DEBUG_SPI, "ERROR - gtm501l_io called, but spi still busy\n"); + } + +} + +static ssize_t gtm501l_sysfs_channel(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct gtm501l_port_data *port_data = NULL; + int i; + + /* Look for the port_data matching this device. */ + if(strcmp("tty", dev->class->name) == 0) { + for (i = 0; i < GTM501L_MAX_MINORS; i++) { + if (gtm501l_serial_ports[i] && + gtm501l_serial_ports[i]->type.serial.dev == dev) { + port_data = gtm501l_serial_ports[i]; + break; + } + } + } + else if(strcmp("net", dev->class->name) == 0) { + port_data = net_to_gtm501l_data(to_net_dev(dev)); + } + + return sprintf(buf, "%s\n", (port_data ? port_data->spec.name : "unknown")); +} + +static DEVICE_ATTR(channel, S_IRUGO, gtm501l_sysfs_channel, NULL); + +static void gtm501l_free_port(struct gtm501l_port_data *port_data) +{ + /* do device type specific cleanup */ + if (port_data->spec.type == GTM501L_PORT_SPEC_SERIAL) { + /* serial device cleanup */ + device_remove_file(port_data->type.serial.dev, &dev_attr_channel); + gtm501l_serial_ports[port_data->type.serial.minor] = 0; + tty_unregister_device(tty_drv, port_data->type.serial.minor); + kfifo_free(port_data->type.serial.throttle_fifo); + } else if (port_data->spec.type == GTM501L_PORT_SPEC_NET) { + /* net device cleanup */ + device_remove_file(&port_data->type.net.net->dev, &dev_attr_channel); + unregister_netdev(port_data->type.net.net); + free_netdev(port_data->type.net.net); + } + + /* do common device deinitialization */ + kfifo_free(port_data->tx_fifo); + kfree(port_data); +} + +static int gtm501l_get_free_port(void) +{ + int i; + + for (i = 0; i < GTM501L_MAX_MINORS; i++) { + if (!gtm501l_serial_ports[i]) + return i; + } + return -1; +} + +static void gtm501l_create_ports(struct gtm501l_device *gtm_dev, + struct gtm501l_port_spec *specs) +{ + struct net_device *net; + struct gtm501l_serial *gtm_ser; + struct gtm501l_port_data *port_data = NULL; + int minor = -1; + int i; + int status; + + for(i = 0; i < GTM501L_PORT_PER_DEV; i++) { + port_data = gtm_dev->port_data[i]; + + if(port_data) { + if(!specs[i].enabled) { + /* A port did exist, but it's gone now */ + gtm501l_free_port(port_data); + gtm_dev->port_data[i] = NULL; + continue; + } + else if (specs[i].type == port_data->spec.type) { + /* Old and new port are of the same type, + * only update the name */ + memcpy(&port_data->spec.name, &specs[i].name, 16); + continue; + } + else { + /* Old and new port have different types */ + gtm501l_free_port(port_data); + gtm_dev->port_data[i] = NULL; + } + } + + /* If this port is not enabled, skip it */ + if(!specs[i].enabled) { + continue; + } + + dprintk(DEBUG_INIT, "%d: (%d) %s\n", i, specs[i].type, specs[i].name); + + port_data = kzalloc(sizeof(struct gtm501l_port_data), GFP_KERNEL); + if (!port_data) + continue; + + memcpy(&port_data->spec, &specs[i], sizeof(struct gtm501l_port_spec)); + + spin_lock_init(&port_data->fifo_lock); + lockdep_set_class_and_subclass(&port_data->fifo_lock, >m501l_key, 0); + + /* common initialization */ + port_data->spi_itf = gtm_dev; + port_data->port_id = i; + port_data->tx_fifo = + status = kfifo_alloc(port_data->tx_fifo, GTM501L_FIFO_SIZE, GFP_KERNEL); + if (status) { + printk(KERN_ERR "GTM501 failed kfifo tx alloc %d\n", status); + kfree(port_data); + continue; + } + /* device specific initialization */ + if (port_data->spec.type == GTM501L_PORT_SPEC_SERIAL) { + /* serial device */ + if ((minor = gtm501l_get_free_port()) == -1) { + kfree(port_data); + continue; + } + gtm_ser = &port_data->type.serial; + gtm_ser->minor = minor; + gtm_ser->dev = + tty_register_device(tty_drv, minor, + >m_dev->spi_dev->dev); + if (!gtm_ser->dev) { + dprintk(DEBUG_INIT, "Registering tty device failed\n"); + kfree(port_data); + continue; + } + gtm501l_serial_ports[minor] = port_data; + spin_lock_init(>m_ser->throttle_fifo_lock); + lockdep_set_class_and_subclass(>m_ser->throttle_fifo_lock, >m501l_key, 0); + status = kfifo_alloc(gtm_ser->throttle_fifo, GTM501l_THROTTLE_FIFO_SIZE, + GFP_KERNEL); + if (status) { + tty_unregister_device(tty_drv, + gtm_ser->minor); + kfree(port_data); + continue; + } + + if (device_create_file(gtm_ser->dev, &dev_attr_channel)) + dev_err(gtm_ser->dev, "Could not create sysfs file for channel\n"); + } + else if (port_data->spec.type == GTM501L_PORT_SPEC_NET) { + /* net device */ + net = alloc_netdev(sizeof(struct gtm501l_port_data *), "gtm%d", + gtm501l_net_init); + if (!net) { + kfifo_free(port_data->tx_fifo); + kfree(port_data); + continue; + } + + *((struct gtm501l_port_data **)netdev_priv(net)) = port_data; + port_data->type.net.net = net; + + if (register_netdev(net)) { + free_netdev(net); + kfifo_free(port_data->tx_fifo); + kfree(port_data); + continue; + } + + if (device_create_file(&net->dev, &dev_attr_channel)) + dev_err(&net->dev, "Could not create sysfs file for channel\n"); + } + + gtm_dev->port_data[i] = port_data; + + } +} + +static void gtm501l_free_device(struct kref *ref) +{ + int i; + struct gtm501l_device *gtm_dev = + container_of(ref, struct gtm501l_device, ref); + struct gtm501l_port_data *port_data; + + tasklet_kill(>m_dev->io_work_tasklet); + + for (i = 0; i < GTM501L_PORT_PER_DEV; i++) { + port_data = gtm_dev->port_data[i]; + if(port_data) + gtm501l_free_port(port_data); + } +#ifdef CONFIG_DEBUG_FS + gtm501l_debugfs_remove(gtm_dev); +#endif + kfree(gtm_dev); +} + +static void gtm501l_spi_complete(void *ctx) +{ + struct gtm501l_device *gtm_dev = (struct gtm501l_device *)ctx; + unsigned int rx_count = 0; + + if(gtm_dev->stats) { + gtm_dev->stats->transfer_finished_wait_start(gtm_dev->frame_stats); + gtm_dev->stats->transfer_decode_start(gtm_dev->frame_stats); + } + + /* did we get removed meanwhile ? */ + if (!test_bit(GTM501L_STATE_PRESENT, >m_dev->flags)) + return; + + if (!gtm_dev->spi_msg.status) { +#if 0 + dma_unmap_single(>m_dev->spi_dev->dev, + gtm_dev->tx_dma[(gtm_dev->tx_buffer_used + 1) % 2], + GTM501L_TRANSFER_SIZE, DMA_TO_DEVICE); + dma_unmap_single(>m_dev->spi_dev->dev, gtm_dev->rx_dma, + GTM501L_TRANSFER_SIZE, DMA_FROM_DEVICE); +#endif + rx_count = gtm501l_demux(gtm_dev, gtm_dev->rx_buffer, + gtm_dev->spi_msg.actual_length); + } else { + spi_err_count++; + printk("SPI transfer error %d - (%d)\n", + gtm_dev->spi_msg.status, spi_err_count); + } + + if(gtm_dev->stats) gtm_dev->stats->decode_finished_may_idle_start(gtm_dev->frame_stats, rx_count); + + clear_bit(GTM501L_STATE_IO_IN_PROGRESS, >m_dev->flags); + + //gtm501l_prepare_tx_buffer(gtm_dev); + + if(test_and_clear_bit(GTM501L_STATE_IO_READY, >m_dev->flags)) + tasklet_hi_schedule(>m_dev->io_work_tasklet); +} + +/* char/tty operations */ + +static void gtm501l_throttle(struct tty_struct *tty) +{ + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + + func_enter(); + + if (port_data) { + func_exit(); + return; + } + + if(!test_bit(GTM501L_RX_FC, &port_data->signal_state)) { + set_bit(GTM501L_RX_FC, &port_data->signal_state); + set_bit(GTM501L_UPDATE, &port_data->signal_state); + } + + func_exit(); +} + +/* To be checked... I can't remember the exact details but the hso driver + * needed a hso_unthrottle_tasklet to prevent hso_throttle being + * called recursively, I am not sure whether this can happen here. + */ +#define UNTHROTTLE_STACK_BUF_SIZE (512) +static void gtm501l_unthrottle(struct tty_struct *tty) +{ + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + struct gtm501l_serial *gtm_ser; + int write_length_remaining, curr_write_len; + char stack_buff[UNTHROTTLE_STACK_BUF_SIZE]; + struct gtm501l_device *gtm_dev = port_data->spi_itf; + + func_enter(); + + if (!port_data) { + func_exit(); + return; + } + + gtm_ser=&port_data->type.serial; + write_length_remaining=kfifo_len(gtm_ser->throttle_fifo); + while (write_length_remaining) { + if (test_bit(TTY_THROTTLED, &tty->flags)) { + func_exit(); + return; + } + curr_write_len = min(write_length_remaining, + UNTHROTTLE_STACK_BUF_SIZE); + curr_write_len = kfifo_out(gtm_ser->throttle_fifo, + stack_buff, curr_write_len); + curr_write_len = tty_insert_flip_string + (tty, stack_buff, + curr_write_len); + write_length_remaining -= curr_write_len; + tty_flip_buffer_push(tty); + } + + clear_bit(GTM501L_RX_FC, &port_data->signal_state); + set_bit(GTM501L_UPDATE, &port_data->signal_state); + + /* If the timer is currently running, stop it and try to initiate a + * transfer immediately */ + if(timer_pending(>m_dev->timer)) { + del_timer_sync(>m_dev->timer); + gtm501l_io((unsigned long)gtm_dev); + } + + func_exit(); +} + +static int gtm501l_tiocmget(struct tty_struct *tty, struct file *filp) +{ + unsigned int value; + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + + func_enter(); + + if (!port_data) { + func_exit(); + return 0; + } + + value = + (test_bit(GTM501L_RTS, &port_data->signal_state) ? TIOCM_RTS : 0) | + (test_bit(GTM501L_DTR, &port_data->signal_state) ? TIOCM_DTR : 0) | + (test_bit(GTM501L_CTS, &port_data->signal_state) ? TIOCM_CTS : 0) | + (test_bit(GTM501L_DSR, &port_data->signal_state) ? TIOCM_DSR : 0) | + (test_bit(GTM501L_DCD, &port_data->signal_state) ? TIOCM_CAR : 0) | + (test_bit(GTM501L_RI, &port_data->signal_state) ? TIOCM_RNG : 0); + + func_exit(); + return value; +} + +static int gtm501l_tiocmset(struct tty_struct *tty, struct file *filp, + unsigned int set, unsigned int clear) +{ + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + + func_enter(); + + if (!port_data) { + func_exit(); + return -ENODEV; + } + + if (set & TIOCM_RTS) + set_bit(GTM501L_RTS, &port_data->signal_state); + if (set & TIOCM_DTR) + set_bit(GTM501L_DTR, &port_data->signal_state); + + if (clear & TIOCM_RTS) + clear_bit(GTM501L_RTS, &port_data->signal_state); + if (clear & TIOCM_DTR) + clear_bit(GTM501L_DTR, &port_data->signal_state); + + set_bit(GTM501L_UPDATE, &port_data->signal_state); + + func_exit(); + return 0; +} + +static int gtm501l_open(struct tty_struct *tty, struct file *filp) +{ + struct gtm501l_serial *gtm_ser = NULL; + struct gtm501l_port_data *port_data; + + func_enter(); + + if ((tty->index > GTM501L_MAX_MINORS) + || (!gtm501l_serial_ports[tty->index])) { + func_exit(); + return -ENODEV; + } + + port_data = gtm501l_serial_ports[tty->index]; + gtm_ser = &port_data->type.serial; + + if (!test_bit(GTM501L_STATE_PRESENT, &port_data->spi_itf->flags)) { + func_exit(); + return -ENODEV; + } + + gtm_ser->open++; + tty->driver_data = port_data; + tty->low_latency = 1; + gtm_ser->tty = tty; + _gtm501l_set_termios(tty, NULL); + + /* signal_update_needed flag will be set by tiocmset */ + clear_bit(GTM501L_RX_FC, &port_data->signal_state); + gtm501l_tiocmset(tty, filp, TIOCM_DTR | TIOCM_RTS, 0); + + kref_get(&port_data->spi_itf->ref); + func_exit(); + return 0; +} + +static void gtm501l_close(struct tty_struct *tty, struct file *filp) +{ + struct gtm501l_serial *gtm_ser = NULL; + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + + func_enter(); + + if ((tty->index > GTM501L_MAX_MINORS) || !port_data) { + func_exit(); + return; + } + + gtm_ser = &port_data->type.serial; + + /* + * ugh, the refcounting... unfortunately open() & close()'s aren't always executed symmetrically. + * There are cases where after a failed open you can still get a close(). We can't handle those + * here. File a tty layer bug. + */ + if(--gtm_ser->open >= 0) { + kref_put(&port_data->spi_itf->ref, gtm501l_free_device); + if( gtm_ser->open == 0) { + kfifo_reset(port_data->tx_fifo); + /* signal_update_needed flag will be set by tiocmset */ + set_bit(GTM501L_RX_FC, &port_data->signal_state); + gtm501l_tiocmset(tty, filp, 0, TIOCM_DTR | TIOCM_RTS); + gtm_ser->tty = NULL; + } + } else gtm_ser->open = 0; + + func_exit(); +} + +static int gtm501l_write(struct tty_struct *tty, const unsigned char *buf, + int count) +{ + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + struct gtm501l_serial *gtm_ser; + unsigned int tx_count; + unsigned char *tmp_buf = (unsigned char *)buf; + struct gtm501l_device *gtm_dev = port_data->spi_itf; + + func_enter(); + + if (!port_data) { + func_exit(); + return -ENODEV; + } + + gtm_ser = &port_data->type.serial; + + tx_count = kfifo_in(port_data->tx_fifo, tmp_buf, count); + total_tty_write+=tx_count; + + /* If the timer is currently running, stop it and try to initiate a + * transfer immediately */ + if(timer_pending(>m_dev->timer)) { + del_timer_sync(>m_dev->timer); + gtm501l_io((unsigned long)gtm_dev); + } + + //printk("Write: wrote %d bytes in fifo (total = %d)\n", tx_count, total_tty_write); + + func_exit(); + + return tx_count; +} + +static int gtm501l_write_room(struct tty_struct *tty) +{ + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + + if (!port_data) { + return -ENODEV; + } + + //func_enter(); + + return GTM501L_FIFO_SIZE - kfifo_len(port_data->tx_fifo); +} + +static void _gtm501l_set_termios(struct tty_struct *tty, struct ktermios *old) +{ + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + struct gtm501l_serial *serial; + struct ktermios *termios; + + if ((!tty) || (!tty->termios) || (!port_data)) { + printk(KERN_ERR "%s: no tty structures", __func__); + return; + } + + serial = &port_data->type.serial; + /* + * * The default requirements for this device are: + * */ + termios = tty->termios; + termios->c_iflag &= ~(IGNBRK /* disable ignore break */ + | BRKINT /* disable break causes interrupt */ + | PARMRK /* disable mark parity errors */ + | ISTRIP /* disable clear high bit of input characters */ + | INLCR /* disable translate NL to CR */ + | IGNCR /* disable ignore CR */ + | ICRNL /* disable translate CR to NL */ + | IXON); /* disable enable XON/XOFF flow control */ + + /* disable postprocess output characters */ + termios->c_oflag &= ~OPOST; + + termios->c_lflag &= ~(ECHO /* disable echo input characters */ + | ECHONL /* disable echo new line */ + | ICANON /* disable erase, kill, werase, and rprnt + special characters */ + | ISIG /* disable interrupt, quit, and suspend special + characters */ + | IEXTEN); /* disable non-POSIX special characters */ + + termios->c_cflag &= ~(CSIZE /* no size */ + | PARENB /* disable parity bit */ + | CBAUD /* clear current baud rate */ + | CBAUDEX); /* clear current buad rate */ + termios->c_cflag |= CS8; /* character size 8 bits */ + + tty_encode_baud_rate(serial->tty, 115200, 115200); + /* + * Force low_latency on; otherwise the pushes are scheduled; + * this is bad as it opens up the possibility of dropping bytes + * on the floor. We don't want to drop bytes on the floor. :) + */ + serial->tty->low_latency = 1; + serial->tty->termios->c_cflag |= B115200; /* baud rate 115200 */ + return; +} + +static void gtm501l_set_termios(struct tty_struct *tty, struct ktermios *old) +{ + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + struct gtm501l_serial *serial; + + func_enter(); + + if (!port_data) { + func_exit(); + return; + } + serial = &port_data->type.serial; + + /* the actual setup */ + if (serial->tty) + _gtm501l_set_termios(tty, old); + else + tty->termios = old; + + /* done */ + func_exit(); + return; +} + +static int gtm501l_chars_in_buffer(struct tty_struct *tty) +{ + struct gtm501l_port_data *port_data = + (struct gtm501l_port_data *)tty->driver_data; + + if (!port_data) + return -ENODEV; + + //func_enter(); + + return kfifo_len(port_data->tx_fifo); +} + +static struct mrst_spi_chip mrst_gtm501l = { + .poll_mode = 0, + .enable_dma = 1, + .type = SPI_FRF_SPI, +}; + +/* spi operations */ + +static int gtm501l_spi_probe(struct spi_device *spi) +{ + struct gtm501l_device *gtm_dev; + int i; + + func_enter(); + + /* we check here only the SPI mode and correct them, if needed */ + if (GTM501L_SPI_MODE != (spi->mode & (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH | SPI_LSB_FIRST | SPI_3WIRE))) { + pr_warning("%s: SPI mode wrong setup, found %d, correct to %d\n", + DRVNAME, spi->mode, GTM501L_SPI_MODE); + spi->mode = GTM501L_SPI_MODE | (SPI_LOOP & spi->mode); + } + + if (spi->mode & SPI_LOOP) { + pr_warning("%s: SPI device in loop back\n", DRVNAME); + } + + /* The Bit_per_word and the maximum speed has to be setup by us, the protocol driver */ + if(spi_b16) + spi->bits_per_word = 16; + else + spi->bits_per_word = 8; + + spi->max_speed_hz = GTM501L_SPI_SPEED; + + spi->controller_data = &mrst_gtm501l; + + if (spi_setup(spi)) { + pr_err("%s: SPI setup does wasn't successful\n", DRVNAME); + func_exit(); + return -ENODEV; + } + + /* initialize structure to hold our device variables */ + gtm_dev = kzalloc(sizeof(struct gtm501l_device), GFP_ATOMIC); + + if (!gtm_dev) { + func_exit(); + return -ENOMEM; + } + gtm_dev->spi_dev = spi; + kref_init(>m_dev->ref); + + /*initialize transfer and dma buffers */ + for(i = 0; i < 2; i++) { + gtm_dev->tx_buffer[i] = kzalloc(GTM501L_TRANSFER_SIZE, GFP_KERNEL | GFP_DMA); + if( 0 == gtm_dev->tx_buffer[i]) { + pr_err("%s: DMA-TX[%d] buffer allocation failed\n", DRVNAME, i); + func_exit(); + return -EIO; + } + } + gtm_dev->rx_buffer = kzalloc(GTM501L_TRANSFER_SIZE, GFP_KERNEL | GFP_DMA); + if( 0 == gtm_dev->rx_buffer) { + pr_err("%s: DMA-RX buffer allocation failed\n", DRVNAME); + func_exit(); + return -EIO; + } + + /* create our tty/net ports */ + gtm501l_create_ports(gtm_dev, gtm501l_default_port_spec); + + spi_set_drvdata(spi, gtm_dev); + + tasklet_init(>m_dev->io_work_tasklet, + (void (*)(unsigned long))gtm501l_io, + (unsigned long)gtm_dev); + + init_timer(>m_dev->timer); + +#ifdef CONFIG_DEBUG_FS + gtm501l_debugfs_init(gtm_dev); +#endif + + /* + * Init GPIO and IRQ, if at least the gpio parameter is set + */ + if (gpio_in < 0) + gpio_in = GTM501L_GPIO0; + + if (request_irq(spi->irq, gtm501l_gpio_interrupt, GTM501L_IRQ_TYPE, + "option", (void *)gtm_dev)) { + kref_put(>m_dev->ref, gtm501l_free_device); + func_exit(); + return -EIO; + } + + set_bit(GTM501L_STATE_PRESENT, >m_dev->flags); + /* + * Schedule tasklet once in case the gpio is active at probe time. + * Otherwise wait for the next interrupt + */ + gtm501l_gpio_interrupt(spi->irq, (void *)gtm_dev); + + func_exit(); + return 0; +} + +static int gtm501l_spi_remove(struct spi_device *spi) +{ + struct gtm501l_device *gtm_dev = + (struct gtm501l_device *)spi_get_drvdata(spi); + + func_enter(); + + del_timer_sync(>m_dev->timer); + + clear_bit(GTM501L_STATE_PRESENT, >m_dev->flags); + free_irq(spi->irq, gtm_dev); + kfree(gtm_dev->tx_buffer[0]); + kfree(gtm_dev->tx_buffer[1]); + kfree(gtm_dev->rx_buffer); + spi_set_drvdata(spi, NULL); + kref_put(>m_dev->ref, gtm501l_free_device); + + func_exit(); + return 0; +} + +static void gtm501l_spi_shutdown(struct spi_device *spi) +{ + func_enter(); +} + +static int gtm501l_spi_suspend(struct spi_device *spi, pm_message_t msg) +{ + func_enter(); + return 0; +} + +static int gtm501l_spi_resume(struct spi_device *spi) +{ + func_enter(); + return 0; +} + +static struct tty_operations gtm501l_serial_ops = { + .open = gtm501l_open, + .close = gtm501l_close, + .write = gtm501l_write, + .write_room = gtm501l_write_room, + .set_termios = gtm501l_set_termios, + .chars_in_buffer = gtm501l_chars_in_buffer, + .tiocmget = gtm501l_tiocmget, + .tiocmset = gtm501l_tiocmset, + .throttle = gtm501l_throttle, + .unthrottle = gtm501l_unthrottle +}; + +static struct spi_driver gtm501l_spi_driver = { + .driver = { + .name = "spi_opt_modem", + .bus = &spi_bus_type, + .owner = THIS_MODULE + }, + .probe = gtm501l_spi_probe, + .remove = __devexit_p(gtm501l_spi_remove), + .shutdown = gtm501l_spi_shutdown, + .suspend = gtm501l_spi_suspend, + .resume = gtm501l_spi_resume, +}; + +/* module exit point */ +static void __exit gtm501l_exit(void) +{ + func_enter(); + tty_unregister_driver(tty_drv); + spi_unregister_driver(>m501l_spi_driver); + dprintk(DEBUG_CLEANUP, "GTM501L driver removed\n"); + func_exit(); +} + +/* module entry point */ +static int __init gtm501l_init(void) +{ + int result = 0; + + func_enter(); + +/* gtm501l_pmic_init_voltages();*/ + gtm501l_pmic_set_wwandisablen(1); + + gtm501l_pmic_set_wwanresetn(0); + msleep(100); + gtm501l_pmic_set_wwanresetn(1); + + memset(gtm501l_serial_ports, 0, sizeof(gtm501l_serial_ports)); + memset(gtm501l_termios, 0, sizeof(gtm501l_termios)); + memset(gtm501l_termios_locked, 0, sizeof(gtm501l_termios_locked)); + + /* initialize lower-edge tty driver */ + tty_drv = alloc_tty_driver(GTM501L_MAX_MINORS); + if (!tty_drv) { + func_exit(); + return -ENOMEM; + } + + tty_drv->magic = TTY_DRIVER_MAGIC; + tty_drv->owner = THIS_MODULE; + tty_drv->driver_name = "gtm501l"; + tty_drv->name = "ttyGTM"; + tty_drv->minor_start = 0; + tty_drv->num = GTM501L_MAX_MINORS; + tty_drv->type = TTY_DRIVER_TYPE_SERIAL; + tty_drv->subtype = SERIAL_TYPE_NORMAL; + tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; + tty_drv->init_termios = tty_std_termios; + tty_drv->init_termios.c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL; + tty_drv->termios = gtm501l_termios; + tty_drv->termios_locked = gtm501l_termios_locked; + + tty_set_operations(tty_drv, >m501l_serial_ops); + + result = tty_register_driver(tty_drv); + if (result) { + printk(KERN_ERR "%s - tty_register_driver failed(%d)\n", + __func__, result); + func_exit(); + return result; + } + + /* + initialize upper-edge spi driver. needs to be done after tty initialization because the spi probe will + race + */ + result = spi_register_driver(>m501l_spi_driver); + if (result) { + printk(KERN_ERR "%s - spi_register_driver failed(%d)\n", + __func__, result); + tty_unregister_driver(tty_drv); + func_exit(); + return result; + } + + dprintk(DEBUG_INIT, "GTM501L driver initialized successfully\n"); + func_exit(); + return 0; +} + +static int gtm501l_net_open(struct net_device *net) +{ + struct gtm501l_port_data *port_data = net_to_gtm501l_data(net); + + func_enter(); + + port_data->type.net.rx_state = WAIT_IP; + port_data->type.net.sync_lost = 0; + port_data->type.net.rx_buf_size = 0; + port_data->type.net.rx_buf_missing = sizeof(struct iphdr); + + /* update remote side it's ok to send us data */ + clear_bit(GTM501L_RX_FC, &port_data->signal_state); + set_bit(GTM501L_UPDATE, &port_data->signal_state); + netif_start_queue(net); + func_exit(); + return 0; +} + +static int gtm501l_net_close(struct net_device *net) +{ + struct gtm501l_port_data *port_data = net_to_gtm501l_data(net); + + func_enter(); + + /* stop remote side from sending us data */ + set_bit(GTM501L_RX_FC, &port_data->signal_state); + set_bit(GTM501L_UPDATE, &port_data->signal_state); + netif_stop_queue(net); + func_exit(); + return 0; +} + +static void gtm501l_push_skb(struct gtm501l_port_data *port_data) +{ + struct gtm501l_net *gtm_net = &port_data->type.net; + struct sk_buff *skb = gtm_net->tx_skb; + unsigned int len; + + func_enter(); + + if (skb && gtm_net->net->flags & IFF_UP) { + len = kfifo_in(port_data->tx_fifo, skb->data, skb->len); + skb_pull(skb, len); + if (skb->len == 0) { + // dev_kfree_skb(skb); // TODO: This causes a crash... + gtm_net->tx_skb = NULL; + netif_start_queue(gtm_net->net); + } + } + + func_exit(); +} + +static int gtm501l_net_start_xmit(struct sk_buff *skb, struct net_device *net) +{ + int result = 0; + struct gtm501l_port_data *port_data = net_to_gtm501l_data(net); + struct gtm501l_net *gtm_net = &port_data->type.net; + + func_enter(); + + netif_stop_queue(net); + + if (gtm_net->tx_skb) { + printk(KERN_ERR "%s tx_skb not null\n", __func__); + result = -EIO; + } else { + gtm_net->tx_skb = skb; + gtm501l_push_skb(port_data); + } + if (result) { + STATS(net).tx_errors++; + netif_start_queue(net); + } else { + STATS(net).tx_packets++; + STATS(net).tx_bytes += skb->len; + /* And tell the kernel when the last transmit started. */ + net->trans_start = jiffies; + } + /* we're done */ + func_exit(); + return result; +} + +#ifndef NETDEVICE_HAS_STATS +static struct net_device_stats *gtm501l_net_get_stats(struct net_device *net) +{ + return &STATS(net); +} +#endif + +/* called when a packet did not ack after watchdogtimeout */ +static void gtm501l_net_tx_timeout(struct net_device *net) +{ + func_enter(); + + /* Tell syslog we are hosed. */ + dev_warn(&net->dev, "Tx timed out.\n"); + + /* Update statistics */ + STATS(net).tx_errors++; + + func_exit(); +} + +static const struct net_device_ops gtm501l_netdev_ops = { + .ndo_open = gtm501l_net_open, + .ndo_stop = gtm501l_net_close, + .ndo_start_xmit = gtm501l_net_start_xmit, +#ifndef NETDEVICE_HAS_STATS + .ndo_get_stats = gtm501l_net_get_stats, +#endif + .ndo_tx_timeout = gtm501l_net_tx_timeout, +}; + +static void gtm501l_net_init(struct net_device *net) +{ + func_enter(); + + /* fill in the other fields */ + net->netdev_ops = >m501l_netdev_ops; + net->watchdog_timeo = GTM501L_NET_TX_TIMEOUT; + net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; + net->type = ARPHRD_NONE; + net->mtu = GTM501L_DEFAULT_MTU; + net->tx_queue_len = 10; + + func_exit(); +} + +struct gtm501l_device *gtm501l_set_stats_ops(struct gtm501_stats_ops *stats) +{ + struct gtm501l_device *gtm_dev = NULL; + int i; + + /* Look for gtm_dev */ + for (i = 0; i < GTM501L_MAX_MINORS; i++) { + if (gtm501l_serial_ports[i] && + gtm501l_serial_ports[i]->spi_itf) { + gtm_dev = gtm501l_serial_ports[i]->spi_itf; + break; + } + } + + if(gtm_dev) + gtm_dev->stats = stats; + + return gtm_dev; +} + +/* module definitions */ +module_init(gtm501l_init); +module_exit(gtm501l_exit); + +module_param_named(backoff, backoff_enabled, uint, S_IRUGO); +MODULE_PARM_DESC(backoff, "Enable (1) or disable (0) backoff timer."); + +module_param_named(gpi, gpio_in, uint, S_IRUGO); +MODULE_PARM_DESC(gpi, "GPIO input base address. (default: -1 => automatic)"); + +module_param_named(b16, spi_b16, bool, S_IRUGO); +MODULE_PARM_DESC(b16, "SPI 16Bit/word or 8Bit/word, default 16Bit"); + +#ifdef DEBUG +module_param_named(debug, gtm501l_debug, uint, S_IRUGO); +MODULE_PARM_DESC(debug, "Debug flags"); +#endif + +MODULE_AUTHOR("Option Wireless"); +MODULE_DESCRIPTION("GTM501L spi driver"); +MODULE_LICENSE("GPL"); +MODULE_INFO(Version, "0.5pre1-option"); + +EXPORT_SYMBOL_GPL(gtm501l_debug); +EXPORT_SYMBOL_GPL(gtm501l_debug_printk); +EXPORT_SYMBOL_GPL(gtm501l_set_stats_ops); + Index: linux-2.6.33/drivers/spi/gtm501l_spi.h =================================================================== --- /dev/null +++ linux-2.6.33/drivers/spi/gtm501l_spi.h @@ -0,0 +1,329 @@ +/**************************************************************************** + * + * Driver for the Option GTM501L spi modem. + * + * Copyright (C) 2008 Option International + * Copyright (C) 2008 Filip Aben <f.aben@option.com> + * Denis Joseph Barrow <d.barow@option.com> + * Jan Dumon <j.dumon@option.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, + * USA + * + * + * + *****************************************************************************/ + +#ifndef _GTM501L_SPI_H +#define _GTM501L_SPI_H +#include <linux/version.h> +#include <linux/tty.h> +#include <linux/device.h> +#include <linux/spi/spi.h> + +#include <linux/netdevice.h> +#include <linux/ip.h> + +#define DRVNAME "gtm501l" + +#define DEBUG + +#ifdef DEBUG +#define DEBUG_FLOW (1 << 0) +#define DEBUG_INIT (1 << 1) +#define DEBUG_CLEANUP (1 << 2) +#define DEBUG_TTY (1 << 3) +#define DEBUG_NET (1 << 4) +#define DEBUG_MUX (1 << 5) +#define DEBUG_DEMUX (1 << 6) +#define DEBUG_SPI (1 << 7) +#define DEBUG_GPIO (1 << 8) + +#define dprintk(f, str...) if(gtm501l_debug & f) gtm501l_debug_printk(__func__, __LINE__, str) + +#define GTM501L_BUFFER_DUMP(prefix_str,buf,len) \ + print_hex_dump(KERN_DEBUG,prefix_str, DUMP_PREFIX_OFFSET,16,1,buf,len,1) + +void gtm501l_debug_printk(const char *function, int line, char *format, ...); +extern int gtm501l_debug; + +#else +#define dprintk(f, str...) +#define GTM501L_BUFFER_DUMP(prefix_str,buf,len) +#endif + +#define func_enter() dprintk(DEBUG_FLOW, "enter\n") +#define func_exit() dprintk(DEBUG_FLOW, "exit\n") + +#define GTM501L_DEFAULT_MTU 1500 +#define GTM501L_DEFAULT_MRU 2500 +#define GTM501L_NET_TX_TIMEOUT (HZ * 10) + +#define GTM501L_IRQ_TYPE IRQ_TYPE_EDGE_FALLING +#define GTM501L_GPIO_TARGET 0 +#define GTM501L_GPIO0 0x3c /* default use Langwell GPIO60 */ + +/* various macro definitions */ +#define GTM501L_MAX_MINORS 256 +#define GTM501L_PORT_PER_DEV 16 +#define GTM501L_TRANSFER_SIZE 2040 +/* GTM501l_THROTTLE_FIFO_SIZE must be a power of 2 + * & larger than GTM501L_TRANSFER_SIZE */ +#define GTM501l_THROTTLE_FIFO_SIZE 4096 +#define GTM501L_FIFO_SIZE 4096 + +/* device flags bitfield definitions */ +#define GTM501L_STATE_PRESENT 0 +#define GTM501L_STATE_IO_IN_PROGRESS 1 +#define GTM501L_STATE_IO_READY 2 + +#define MUX_CHANNEL(x) ((x >> MUX_CHANNEL_SHIFT) & 0xF) +#define MUX_CHANNEL_SHIFT 0 +#define MUX_BLOCK_TYPE(x) ((x >> MUX_BLOCK_TYPE_SHIFT) & 0x3) +#define MUX_BLOCK_TYPE_SHIFT 4 +#define MUX_DEVICE(x) ((x >> MUX_DEVICE_SHIFT) & 0x3) +#define MUX_DEVICE_SHIFT 6 +#define MUX_BURST_SIZE 512 + +#define MUX_DATA_TRANSFER 0 +#define MUX_BURST_TRANSFER 1 +#define MUX_CONTROL_TRANSFER 2 + +#define MUX_CONTROL_BYTE(channel,type,device) ( \ + (channel<<MUX_CHANNEL_SHIFT) | \ + (type<<MUX_BLOCK_TYPE_SHIFT) | \ + (device<<MUX_DEVICE_SHIFT) \ + ) + +#define MUX_DCD(x) ((x >> MUX_DCD_SHIFT) & 0x1) +#define MUX_DCD_SHIFT 0 +#define MUX_CTS(x) ((x >> MUX_CTS_SHIFT) & 0x1) +#define MUX_CTS_SHIFT 1 +#define MUX_DSR(x) ((x >> MUX_DSR_SHIFT) & 0x1) +#define MUX_DSR_SHIFT 2 +#define MUX_RI(x) ((x >> MUX_RI_SHIFT) & 0x1) +#define MUX_RI_SHIFT 3 +#define MUX_DTR(x) ((x >> MUX_DTR_SHIFT) & 0x1) +#define MUX_DTR_SHIFT 4 +#define MUX_RTS(x) ((x >> MUX_RTS_SHIFT) & 0x1) +#define MUX_RTS_SHIFT 5 +#define MUX_LINK(x) ((x >> MUX_LINK_SHIFT) & 0x1) +#define MUX_LINK_SHIFT 7 + +#define MUX_INVALID 0 +#define MUX_SLAVE_TO_MASTER 1 +#define MUX_MASTER_TO_SLAVE 2 +#define MUX_INVALID2 3 + +#define GTM501L_SPI_MODE SPI_MODE_1 /* SPI Mode 1 currently used */ + +#define GTM501L_SPI_SPEED 12500000 + +/* flow control bitfields */ +#define GTM501L_DCD 0 +#define GTM501L_CTS 1 +#define GTM501L_DSR 2 +#define GTM501L_RI 3 +#define GTM501L_DTR 4 +#define GTM501L_RTS 5 +#define GTM501L_TX_FC 6 +#define GTM501L_RX_FC 7 +#define GTM501L_UPDATE 8 + +#define GTM501L_MAX_EMPTY 500 +#define GTM501L_BACKOFF_TIMER (HZ / 2) + +struct gtm501l_device { + struct spi_device *spi_dev; + struct kref ref; + struct gtm501l_port_data *port_data[GTM501L_PORT_PER_DEV]; + struct tasklet_struct io_work_tasklet; + unsigned long flags; + dma_addr_t rx_dma; + dma_addr_t tx_dma[2]; + + unsigned char *rx_buffer; + unsigned char *tx_buffer[2]; + int tx_buffer_used; + int tx_count; + + struct spi_message spi_msg; + struct spi_transfer spi_xfer; + + int gpio_irq; + int round_robin_index; + + struct timer_list timer; + int empty_transfers; + +#ifdef CONFIG_DEBUG_FS + struct dentry *debugfs; /* debugfs parent directory */ + struct gtm501l_frame_stats *frame_stats; +#endif + + struct gtm501_stats_ops *stats; +}; + +struct gtm501l_serial { + struct device *dev; + struct tty_struct *tty; + struct kfifo *throttle_fifo; + spinlock_t throttle_fifo_lock; + int minor; + int open; +}; + +enum rx_parse_state { + syncing, + getting_frame_len, + filling_skb, + WAIT_IP, + WAIT_DATA, + WAIT_SYNC +}; + +#undef NETDEVICE_HAS_STATS + +struct gtm501l_net { + enum rx_parse_state rx_state; + int sync_lost; + struct sk_buff *tx_skb; + struct sk_buff *rx_skb; + unsigned short rx_frame_len; + struct net_device *net; + unsigned short rx_buf_size; + unsigned short rx_buf_missing; + struct iphdr rx_ip_hdr; +#ifndef NETDEVICE_HAS_STATS + struct net_device_stats stats; +#endif +}; + +#define GTM501L_PORT_SPEC_SERIAL 0 +#define GTM501L_PORT_SPEC_NET 1 + +struct gtm501l_port_spec { + int enabled; + int type; + char name[16]; +}; + +struct gtm501l_port_data { + struct gtm501l_device *spi_itf; + int port_id; + struct gtm501l_port_spec spec; + struct kfifo *tx_fifo; + spinlock_t fifo_lock; + unsigned long signal_state; + union { + struct gtm501l_serial serial; + struct gtm501l_net net; + } type; +}; + +#define net_to_gtm501l_data(net) *((struct gtm501l_port_data **)netdev_priv(net)) + +#ifdef NETDEVICE_HAS_STATS +#define STATS(net) ((net)->stats) +#else +#define STATS(net) (((struct gtm501l_port_data *)net_to_gtm501l_data(net))->type.net.stats) +#endif + +#ifdef CONFIG_DEBUG_FS + +/** + * transfer SPI frame sequence, can be used for global sequence state or for per CPU seq state variable + */ +enum gtm501l_fsequence { /* frame sequence start states */ + none, /* undefined state */ + idle, /* idle state host driver waits */ + encode, /* encoding SPI frame */ + encode_interrupt_decode, /* encoding SPI frame started and interrupts decoding frame */ + decode, /* decoding SPI frame */ + decode_interrupt_encode /* decoding SPI frame started and interrupts decoding frame */ +}; + +/** + * job time with the support for interrupt time correction, which me be used only for encoding and decoding time + * measurements + */ +struct gtm501l_jtime { /* job time */ + ktime_t start; /* start time for that job */ + ktime_t correct; /* correction time, if job was interrupted */ + u32 dt; /* delta time need for that job in us */ + u32 min_dt; /* min time need for that job is us */ + u32 max_dt; /* max time need for that job is us */ + u64 total; /* total time need for that job is us */ + u32 bug; /* bug counter for negative time delta */ +}; + +/** + * frame statistics + */ +struct gtm501l_frame_stats { /* frame transfer statistics */ + spinlock_t lock; /* lock for that structure */ + enum gtm501l_fsequence seq[NR_CPUS]; /* current sequence for each CPU separate */ + struct gtm501l_jtime idle; /* timings for idle, just waiting for the application or GTM501L become busy */ + struct gtm501l_jtime encode; /* timings for encoding SPI frame */ + struct gtm501l_jtime transceive; /* timings for tranceiving SPI frame */ + struct gtm501l_jtime decode; /* timings for decoding SPI frame */ + struct gtm501l_jtime wait; /* timings for waiting for GTM501L become ready */ + struct gtm501l_jtime cycle; /* timings for a SPI frame cycle without idle time */ + struct kfifo *transmit_id_pipe; /* fifo pipe frame id to transmit task */ + struct kfifo *decode_id_pipe; /* fifo pipe frame id to decode task */ + struct kfifo *decode_txb_pipe; /* fifo pipe number of transmit byte to decode task for analysis */ + struct kfifo *decode_dt_pipe; /* fifo pipe SPI frame transfer time to decode task for analysis */ + u32 transmit_id; /* id and number of transmit SPI frames */ + u32 receive_id; /* id and number of received SPI frames */ + u32 encode_start_id; /* id and number of started encoded frames */ + u32 encode_end_id; /* id and number of finished encoded frames */ + u32 decode_start_id; /* id and number of started decoded frames */ + u32 decode_end_id; /* id and number of started decoded frames */ + u32 idles; /* number of entered idle states */ + u32 waits; /* number of entered wait states */ + u32 max_tx_bytes; /* maximum transmitted bytes in a frame */ + u32 max_rx_bytes; /* maximum received bytes in a frame */ + u64 total_tx_bytes; /* total transmitted bytes in a frame for calculating average */ + u64 total_rx_bytes; /* total received bytes in a frame for calculating average */ + u32 first_tx_bytes; /* first transmitted bytes in a frame for calculating average */ + u32 first_rx_bytes; /* first received bytes in a frame for calculating average */ + u32 max_tx_rate; /* maximum transmitted bytes per time rate in bytes/sec */ + u32 max_rx_rate; /* maximum received bytes per time rate in bytes/sec */ + u32 encode_pass_decode; /* encode task pass decode task */ + u32 encode_interrupts_decode; /* encode task interrupts decode task on the same CPU */ + u32 decode_pass_encode; /* decode task pass encode task */ + u32 decode_interrupts_encode; /* decode task interrupts encode task on the same CPU */ + u32 encode_bug; /* number of counted bugs for encode process */ + int encode_buffers_used; /* number of need encode buffers */ + u32 decode_bug; /* number of counted bugs for the decode process */ + int decode_buffers_used; /* number of need decode buffers */ + struct dentry *debugfs; /* debugfs entry for the frame_stats file */ +}; + +#endif + +struct gtm501_stats_ops { + void (*wait_finished)(struct gtm501l_frame_stats *fstats); + void (*encode_start_idle_finished)(struct gtm501l_frame_stats *fstats); + void (*encode_finished)(struct gtm501l_frame_stats *fstats, unsigned int tx_bytes); + void (*transfer_start)(struct gtm501l_frame_stats *fstats); + void (*transfer_finished_wait_start)(struct gtm501l_frame_stats *fstats); + void (*transfer_decode_start)(struct gtm501l_frame_stats *fstats); + void (*decode_finished_may_idle_start)(struct gtm501l_frame_stats *fstats, unsigned int rx_bytes); +}; + +/* Prototypes */ +struct gtm501l_device *gtm501l_set_stats_ops(struct gtm501_stats_ops *stats); + +#endif
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
