Exar USB Serial Driver
======================
+Version 1B, 11/6/2015
+Fixed Bug: The conditional logic to support kernel 3.9 was incorrect(line 396 in xr_usb_serial_common.c).
+
Version 1A, 1/9/2015
This driver will work with any USB UART function in these Exar devices:
--- /dev/null
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+static void *smbios_base = 0;
+/** SM-BIOS entry point structure */
+struct smbios_entry_point_struct *smbios_entry_point = 0;
+/** DMI-BIOS entry point structure */
+struct dmibios_entry_point_struct *dmibios_entry_point = 0;
+/** SM-BIOS, resp. DMI-BIOS structures base address; starting point */
+void *smbios_structures_base = 0;
+/** enumeration of SM-BIOS, resp. DMI-BIOS types that do have subtypes */
+__u8 smbios_types_with_subtypes[] = { TYPES_WITH_SUBTYPES };
+/** contains the SMBIOS Version, e.g. V2.31 */
+char smbios_version_string[32];
+/** \fn unsigned char smbios_check_entry_point (void * addr)
+ * \brief checks the entry point structure for correct checksum
+ * \param addr pointer to the entry point structure
+ * \return the checksum of the entry point structure, should be '0'
+ *
+ * This function checks the entry point structure for correct checksum.
+ * The checksum is calculated with adding every byte of the structure
+ * to the checksum byte. The entry point structure is considered correct
+ * if the checksum byte is 0.
+ *
+ * \author Markus Lyra
+ * \author Thomas Bretthauer
+ * \date October 2000
+ */
+
+unsigned char smbios_check_entry_point (void *addr)
+{
+ unsigned char *i;
+ unsigned char checksum = 0;
+ unsigned char length =((struct smbios_entry_point_struct *) addr)->entry_point_length;
+ /* calculate checksum for entry point structure (should be 0) */
+ for (i = (unsigned char *) addr; i < (unsigned char *) addr + length; i++)
+ checksum += *i;
+ return checksum;
+}
+
+struct smbios_entry_point_struct * smbios_find_entry_point (void *base)
+{
+ struct smbios_entry_point_struct *entry_point = 0; /** SM-BIOS entry point */
+ unsigned int *temp; /** temp. pointer */
+
+
+ /* search for the magic dword - '_SM_� as DWORD formatted - on paragraph boundaries */
+ for (temp = base;
+ !entry_point && temp < (unsigned int *) base + BIOS_MAP_LENGTH;
+ temp += 4)
+ {
+ /* found the identifier ? */
+ if (*temp == SMBIOS_MAGIC_DWORD)
+ {
+ /* check if entry point valid (build checksum) */
+ if (!(smbios_check_entry_point (temp)))
+ {
+ entry_point = (struct smbios_entry_point_struct *) temp;
+
+ /* fix display of Bios version string */
+ /* SMBios version is known as 2.1, 2.2, 2.3 and 2.3.1, never as 2.01 (JB) */
+ SM_BIOS_DEBUG("SM-BIOS V%d.%d entry point found at 0x%x\n",
+ entry_point->major_version, entry_point->minor_version, (unsigned int) temp);
+
+ SM_BIOS_DEBUG("V%d.%d\n", entry_point->major_version, entry_point->minor_version);
+ }
+ }
+ }
+ return entry_point;
+}
+struct dmibios_entry_point_struct *dmibios_find_entry_point (void *base)
+{
+ struct dmibios_entry_point_struct *entry_point = 0; /** DMI-BIOS entry point */
+ unsigned char *temp = 0; /** temp. pointer */
+ unsigned char biossignature[] = /** '_DMI20_NT_' */
+ { 0x5f, 0x44, 0x4d, 0x49, 0x32, 0x30, 0x5f, 0x4e, 0x54, 0x5f };
+
+ /* search for the DMI-BIOS signature on character boundary (hm?) */
+ for (temp = base;
+ !entry_point &&
+ temp < (__u8 *) base + BIOS_MAP_LENGTH - sizeof (biossignature) - 32;
+ temp++)
+ {
+ unsigned long *tempdword = (unsigned long *) temp;
+
+ /* found the identifier '_DMI' ? (beginning of signature) */
+ if (*tempdword == DMIBIOS_MAGIC_DWORD)
+ {
+ entry_point = (struct dmibios_entry_point_struct *) temp;
+
+ SM_BIOS_DEBUG ("DMI-BIOS revision %d entry point at 0x%x\n",
+ entry_point->revision, (unsigned int) temp);
+
+ sprintf(smbios_version_string, "V%d\n", entry_point->revision);
+
+ if (memcmp (temp, biossignature, sizeof (biossignature)) == 0)
+ SM_BIOS_DEBUG ("DMI BIOS successfully identified\n");
+ }
+ }
+ return entry_point;
+}
+void dump_smbios_hex(unsigned char *p,int len)
+{
+ int i;
+ SM_BIOS_DEBUG("dump_smbios_hex length:%d\n",len);
+ for(i=0;i<len;i++)
+ {
+ if((p[i] == 0xc0)&&(p[i+1]==0x06))
+ SM_BIOS_DEBUG("Found 0xc0 at offset:%d 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x \n\t",i,p[i],p[i+1],p[i+2],p[i+3],p[i+4],p[i+5]);
+ }
+}
+int smbios_type_has_subtype (unsigned char type)
+{
+ int i;
+
+
+ for (i = 0; i < sizeof (smbios_types_with_subtypes); i++)
+ if (type == smbios_types_with_subtypes[i])
+ return 1;
+
+ return 0;
+}
+
+int smbios_get_struct_length (struct smbios_struct * struct_ptr)
+{
+ /* jump to string list */
+ unsigned char *ptr = (unsigned char *) struct_ptr + struct_ptr->length;
+
+ /* search for the end of string list */
+ while (ptr[0] != 0x00 || ptr[1] != 0x00)
+ ptr++;
+ ptr += 2; /* terminating 0x0000 should be included */
+
+ return (int) ptr - (int) struct_ptr;
+}
+
+unsigned int smbios_get_readable_name(char *name, struct smbios_struct *struct_ptr)
+{
+ switch(struct_ptr->type)
+ {
+ case 0: return sprintf (name, "%s", RD_BIOS);
+ case 1: return sprintf (name, "%s", RD_SYSTEM);
+ case 2: return sprintf (name, "%s", RD_BASEBOARD);
+ case 3: return sprintf (name, "%s", RD_ENCLOSURE);
+ case 4: return sprintf (name, "%s", RD_PROCESSOR);
+ case 5: return sprintf (name, "%s", RD_MEMCTRL);
+ case 6: return sprintf (name, "%s", RD_MEMMOD);
+ case 7: return sprintf (name, "%s", RD_CACHE);
+ case 8: return sprintf (name, "%s", RD_PORT);
+ case 9: return sprintf (name, "%s", RD_SLOT);
+ case 10: return sprintf (name, "%s", RD_ONBOARD);
+ case 11: return sprintf (name, "%s", RD_OEMSTRINGS);
+ case 12: return sprintf (name, "%s", RD_SYSTEMCONFIG);
+ case 13: return sprintf (name, "%s", RD_BIOSLANG);
+ case 14: return sprintf (name, "%s", RD_GROUPASSOC);
+ case 15: return sprintf (name, "%s", RD_EVENTLOG);
+ case 16: return sprintf (name, "%s", RD_MEMARRAY);
+ case 17: return sprintf (name, "%s", RD_MEMDEV);
+ case 18: return sprintf (name, "%s", RD_32MEMERR);
+ case 19: return sprintf (name, "%s", RD_MEMMAPPEDADR);
+ case 20: return sprintf (name, "%s", RD_MEMMAPPEDDEV);
+ case 21: return sprintf (name, "%s", RD_POINTINGDEV);
+ case 22: return sprintf (name, "%s", RD_BATTERY);
+ case 23: return sprintf (name, "%s", RD_RESET);
+ case 24: return sprintf (name, "%s", RD_SECURITY);
+ case 25: return sprintf (name, "%s", RD_PWRCTRL);
+ case 26: return sprintf (name, "%s", RD_VOLTAGE);
+ case 27: return sprintf (name, "%s", RD_COOLINGDEV);
+ case 28: return sprintf (name, "%s", RD_TEMP);
+ case 29: return sprintf (name, "%s", RD_CURRENT);
+ case 30: return sprintf (name, "%s", RD_RMTACCESS);
+ case 31: return sprintf (name, "%s", RD_BIS);
+ case 32: return sprintf (name, "%s", RD_BOOT_INFO);
+ case 33: return sprintf (name, "%s", RD_64MEMERR);
+ case 34: return sprintf (name, "%s", RD_MANAGDEV);
+ case 35: return sprintf (name, "%s", RD_MANAGDEVCOMP);
+ case 36: return sprintf (name, "%s", RD_MANAGDEVTHRESH);
+ case 37: return sprintf (name, "%s", RD_MEMCHANNEL);
+ case 38: return sprintf (name, "%s", RD_IPMI);
+ case 39: return sprintf (name, "%s", RD_PWRSUP);
+ case 126: return sprintf (name, "%s", RD_INACTIVE);
+ case 127: return sprintf (name, "%s", RD_EOT);
+ default: return sprintf (name, "%d", struct_ptr->type);
+ }
+}
+unsigned int smbios_get_readable_name_ext(char *name, struct smbios_struct *struct_ptr)
+{
+ return sprintf (name, "%d-%d", struct_ptr->type, struct_ptr->subtype);
+}
+
+int smbios_make_dir_entries (void)
+{
+ int i;
+ unsigned int raw_name_length = 0;
+ char raw_name[12]; /* e.g. 0.0 for structure type 0 , first instance */
+ unsigned int readable_name_length = 0;
+ char readable_name[64]; /* e.g. Bios.0 for structure type 0 , first instance */
+ struct smbios_struct *struct_ptr = smbios_structures_base;
+ /*
+ * for every SMBIOS structure do ...
+ */
+ for (i = 0; i < smbios_entry_point->no_of_structures; i++)
+ {
+ memset(raw_name,0,12);
+ memset(readable_name,0,64);
+ /*
+ * generate an unique name for the file: "type[-subtype].count"
+ */
+ if (smbios_type_has_subtype (((struct smbios_struct *) struct_ptr)->type))
+ {
+ /* name will contain the raw file name, it equals the structure type (e.g. 1 for Type 1).
+ * readable_name contains the interpreted file name (e.g. System for Type 1)
+ */
+ raw_name_length = sprintf (raw_name, "%d-%d", struct_ptr->type, struct_ptr->subtype);
+ readable_name_length = smbios_get_readable_name_ext(readable_name, struct_ptr);
+ //printk(KERN_INFO "[%s] smbios_type_has_subtype[%d] length:%d\n",raw_name,struct_ptr->type,struct_ptr->length);
+ }
+ else
+ {
+ raw_name_length = sprintf (raw_name, "%d", struct_ptr->type);
+ readable_name_length = smbios_get_readable_name(readable_name, struct_ptr);
+ //printk(KERN_INFO "[%s] smbios_type_has type:%d length:%d\n",readable_name,struct_ptr->type,struct_ptr->length);
+ }
+
+ /*
+ * go to the next structure
+ */
+ struct_ptr =(struct smbios_struct *) ((unsigned char *) struct_ptr + smbios_get_struct_length(struct_ptr));
+ }
+
+ return 0;
+}
+
+int smbios_check_if_have_exar_config(unsigned char *config0,unsigned char *config1)
+{
+ int i;
+ int result = -1;
+ unsigned char *p;
+ smbios_base = ioremap (BIOS_START_ADDRESS, BIOS_MAP_LENGTH);
+ if(!smbios_base)
+ {
+ SM_BIOS_DEBUG ("ioremap() for entry point failed\n");
+ result = -ENXIO;
+ return result;
+ }
+ //printk(KERN_INFO "ioremap bios base at 0x%p\n", smbios_base);
+ if (!(smbios_entry_point = smbios_find_entry_point (smbios_base)))
+ {
+ SM_BIOS_DEBUG ("SM-BIOS entry point not found\n");
+ iounmap (smbios_base);
+ result = -ENXIO;
+ return result;
+
+ }
+ /*
+ * for SM-BIOS:
+ * check if Pointer to DMI structures exist.
+ * intermediate_string (_DMI_) is not '\0' terminated,
+ * so strncmp() with sizeof(DMI_STRING) - 1 is needed.
+ */
+ if (smbios_entry_point)
+ {
+ if (strncmp((char *) &(smbios_entry_point->intermediate_string),
+ DMI_STRING, sizeof (DMI_STRING) - 1))
+ {
+ SM_BIOS_DEBUG ("Pointer to DMI structures not found!\n");
+
+ }
+ }
+
+ /*
+ * map the SM-BIOS structures physical address range.
+ * the 'real' smbios_structures_base contains the starting
+ * address, where the instances of dmi structures are located.
+ */
+ if (smbios_entry_point)
+ {
+ if (!(smbios_structures_base =
+ ioremap (smbios_entry_point->struct_table_address,
+ (unsigned long) smbios_entry_point->struct_table_length)))
+ {
+ SM_BIOS_DEBUG("ioremap() for structures table failed\n");
+ iounmap (smbios_base);
+ result = -ENXIO;
+ return result;
+ }
+ }
+ SM_BIOS_DEBUG(KERN_INFO "smbios_structures_base to 0x%p length %d no_of_structures:%d\n",
+ smbios_structures_base,
+ smbios_entry_point->struct_table_length,
+ smbios_entry_point->no_of_structures);
+
+ //dump_smbios_hex((unsigned char *)smbios_structures_base,smbios_entry_point->struct_table_length);
+ p = (unsigned char *)smbios_structures_base;
+ for(i=0;i<smbios_entry_point->struct_table_length;i++)
+ {
+ if((p[i] == 0xc0)&&(p[i+1]==0x06))
+ {
+ SM_BIOS_DEBUG("Found 0xc0 at offset:%d 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x \n\t",i,p[i],p[i+1],p[i+2],p[i+3],p[i+4],p[i+5]);
+ *config0 = p[i+4];
+ *config1 = p[i+5];
+ result = 0;
+ break;
+ }
+ }
+ //smbios_make_dir_entries();
+ iounmap (smbios_structures_base);
+ iounmap (smbios_base);
+ return result;
+
+}
+/*
+void dmi_dump_backup(void)
+{
+ const char *board_vendor, *board_name,*board_serial;
+ const struct dmi_device *dmi;
+ struct dmi_dev_onboard *donboard;
+ board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
+ board_name = dmi_get_system_info(DMI_BOARD_NAME);
+ board_serial = dmi_get_system_info(DMI_BOARD_SERIAL);
+ printk(KERN_INFO "DMI_BOARD_VENDOR:%s\n",board_vendor);
+ printk(KERN_INFO "DMI_BOARD_NAME:%s\n",board_name);
+ printk(KERN_INFO "DMI_BOARD_SERIAL:%s\n",board_serial);
+ for(i=0;i<256;i++)
+ {
+ dmi = NULL;
+ //printk(KERN_INFO "dmi_find_device<%d>\n",i);
+ while ((dmi = dmi_find_device(i,NULL, dmi)) != NULL)
+ {
+ //donboard = dmi->device_data;
+ printk(KERN_INFO "<%d>Found name:%s type:%d \n",i,dmi->name,dmi->type);
+ }
+ }
+
+}
+*/
+
--- /dev/null
+/* Copyright (C) 2001-2001 Fujitsu Siemens Computers
+ Joachim Braeuer
+ This file is part of smbios
+
+ smbios is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License,
+ or (at your option) any later version.
+
+ smbios 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 smbios; see the file COPYING. If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+*/
+
+/* $Id: bios.h,v 1.2 2002/09/03 10:33:12 bretthauert Exp $
+ *
+ * $Log: bios.h,v $
+ * Revision 1.2 2002/09/03 10:33:12 bretthauert
+ * fixed a bug with 2.4 kernels (changed kmalloc parameter from
+ * GFP_BUFFER to GFP_KERNEL
+ *
+ * Revision 1.1 2001/09/15 14:52:43 bretthauert
+ * initial release
+ *
+ */
+
+/** \file bios.h
+ * declarations and prototypes of DMI-BIOS and SM-BIOS stuff
+ *
+ * \author Markus Lyra
+ * \author Thomas Bretthauer
+ * \author Joachim Braeuer
+ * \version 0.11
+ * \date January 2001
+ */
+
+#ifndef __SM_BIOS_H__
+#define __SM_BIOS_H__
+
+#include <linux/types.h>
+//#define _EN_DEBUG_ 1
+#ifdef _EN_DEBUG_
+# define SM_BIOS_DEBUG(fmt, args...) printk( KERN_DEBUG "smbios: " fmt, ## args)
+#else
+# define SM_BIOS_DEBUG(fmt, args...) /* not debugging: nothing */
+#endif
+/*
+ * Magic numbers
+ */
+
+/** start address of BIOS segment to scanned for SM-BIOS and DMI-BIOS */
+#define BIOS_START_ADDRESS 0xF0000
+/** length of the scanned BIOS area for SM-BIOS and DMI-BIOS */
+#define BIOS_MAP_LENGTH 0x10000
+/** magic 4 bytes to identify SM-BIOS entry point, paragraph boundary */
+#define SMBIOS_MAGIC_DWORD 0x5F4D535F /* anchor string "_SM_" */
+/** magic 4 bytes to identify DMI-BIOS entry point, byte boundary */
+#define DMIBIOS_MAGIC_DWORD 0x494d445f /* anchor string "_DMI" */
+/** identifier for SM-BIOS structures within SM-BIOS entry point */
+#define DMI_STRING "_DMI_"
+/** list of types which are known to have subtyes; expandable! */
+#define TYPES_WITH_SUBTYPES 185, 187, 208, 209, 210, 211, 212, 254
+/** maximum block size for proc read function */
+#define PROC_BLOCK_SIZE (3*1024)
+
+
+/** mode raw/cooked */
+#define FILE_MODE_RAW 0
+#define FILE_MODE_COOKED 1
+
+/*
+ * Structures
+ */
+
+/** SM-BIOS entry point structure
+ * the SMBIOS Entry Point structure described below can be located by
+ * application software by searching for the anchor string on paragraph
+ * (16 byte) boundaries within the physical memory address range 000F0000h to
+ * 000FFFFFh. This entry point encapsulates an intermediate anchor string
+ * that is used by some existing DMI browsers.
+ *
+ * @note While the SMBIOS Major and Minor Versions (offsets 06h and 07h)
+ * currently duplicate the information present in the SMBIOS BCD Revision
+ * (offset 1Dh), they provide a path for future growth in this specification.
+ * The BCD Revision, for example, provides only a single digit for each of
+ * the major and minor version numbers.
+ */
+struct smbios_entry_point_struct
+{
+ /** "_SM_", specified as four ASCII characters (5F 53 4D 5F) */
+ __u32 anchor_string;
+ /** checksum of the Entry Point Structure (EPS). This value, when added to
+ * all other bytes in the EPS, will result in the value 00h (using 8 bit
+ * addition calculations). Values in the EPS are summed starting at offset
+ * 00h, for Entry Point Length bytes.*/
+ __u8 entry_point_checksum;
+ /** Length of the Entry Point Structure, starting with the Anchor String
+ * field, in bytes, currently 1Fh. */
+ __u8 entry_point_length;
+ /** identifies the major version of this specification implemented in
+ * the table structures, e.g. the value will be 0Ah for revision 10.22
+ * and 02h for revision 2.1 */
+ __u8 major_version;
+ /** identifies the minor version of this specification implemented in
+ * the table structures, e.g. the value will be 16h for revision 10.22
+ * and 01h for revision 2.1 */
+ __u8 minor_version;
+ /** size of the largest SMBIOS structure, in bytes, and encompasses the
+ * structure's formatted area and text strings. This is the value returned
+ * as StructureSize from the Plug-n-Play 'Get SMBIOS Information' function */
+ __u16 max_struct_size;
+ /** identifies the EPS revision implemented in this structure and identifies
+ * the formatting of offsets 0Bh to 0Fh, one of:
+ * 00h Entry Point based on SMBIOS 2.1 definition; formatted area is
+ * reserved and set to all 00h.
+ * 01h-FFh reserved for assignment via this specification */
+ __u8 revision;
+ /** the value present in the Entry Point Revision field defines the
+ * interpretation to be placed upon these5 bytes. */
+ __u8 formated_area[5];
+ /** "_DMI_", specified as five ASCII characters (5F 44 4D 49 5F) */
+ __u8 intermediate_string[5];
+ /** checksum of the Intermediate Entry Point Structure (IEPS). This value,
+ * when added to all other bytes in the IEPS, will result in the value 00h
+ * (using 8 bit addition calculations). Values in the IEPS are summed
+ * starting at offset 10h, for 0Fh bytes */
+ __u8 intermediate_checksum;
+ /** the 32 bit physical starting address of the read-only SMBIOS Structure
+ * Table, that can start at any 32 bit address. This area contains all of the
+ * SMBIOS structures fully packed together. These structures can then be
+ * parsed to produce exactly the same format as that returned from a 'Get
+ * SMBIOS Structure' function call. */
+ __u16 struct_table_length;
+ __u32 struct_table_address;
+ __u16 no_of_structures;
+ __u8 bcd_revision;
+}__attribute__ ((packed));
+
+/** SM-BIOS and DMI-BIOS structure header */
+struct smbios_struct
+{
+ __u8 type ;
+ __u8 length ;
+ __u16 handle ;
+ __u8 subtype;
+ /* ... other fields are structure dependend ... */
+} __attribute__ ((packed));
+
+/** DMI-BIOS structure header */
+struct dmibios_table_entry_struct
+{
+ __u16 size;
+ __u16 handle;
+ __u32 procedure;
+}__attribute__ ((packed));
+
+/** DMI-BIOS entry point structure */
+struct dmibios_entry_point_struct
+{
+ __u8 signature[10];
+ __u8 revision;
+ struct dmibios_table_entry_struct entry[1];
+}__attribute__ ((packed));
+
+/** readable names for smbios structures, they serve as filenames in the /proc file system */
+#define RD_BIOS "bios"
+#define RD_SYSTEM "system"
+#define RD_BASEBOARD "baseboard"
+#define RD_ENCLOSURE "enclosure"
+#define RD_PROCESSOR "processor"
+#define RD_MEMCTRL "memory_controller"
+#define RD_MEMMOD "memory_module"
+#define RD_CACHE "cache"
+#define RD_PORT "port_connector"
+#define RD_SLOT "system_slot"
+#define RD_ONBOARD "onboard_device"
+#define RD_OEMSTRINGS "oem_strings"
+#define RD_SYSTEMCONFIG "system_configuration"
+#define RD_BIOSLANG "bios_language"
+#define RD_GROUPASSOC "group_association"
+#define RD_EVENTLOG "system_event_log"
+#define RD_MEMARRAY "physical_memory_array"
+#define RD_MEMDEV "physical_memory_device"
+#define RD_32MEMERR "32bit_memory_error_information"
+#define RD_MEMMAPPEDADR "memory_array_mapped_address"
+#define RD_MEMMAPPEDDEV "memory_device_mapped_address"
+#define RD_POINTINGDEV "pointing_device"
+#define RD_BATTERY "portable_battery"
+#define RD_RESET "system_reset"
+#define RD_SECURITY "hardware_security"
+#define RD_PWRCTRL "system_power_controls"
+#define RD_VOLTAGE "voltage_probe"
+#define RD_COOLINGDEV "cooling_device"
+#define RD_TEMP "temperature_probe"
+#define RD_CURRENT "current_probe"
+#define RD_RMTACCESS "out_of_band_remote_access"
+#define RD_BIS "boot_integrity_services"
+#define RD_BOOT_INFO "system_boot_information"
+#define RD_64MEMERR "64bit_memory_error_information"
+#define RD_MANAGDEV "management_device"
+#define RD_MANAGDEVCOMP "management_device_component"
+#define RD_MANAGDEVTHRESH "management_device_thresholds"
+#define RD_MEMCHANNEL "memory_channel"
+#define RD_IPMI "ipmi_information"
+#define RD_PWRSUP "system_power_supply"
+#define RD_INACTIVE "inactive"
+#define RD_EOT "end_of_table"
+
+
+//extern smbios_entry_point_struct * smbios_entry_point; /* start of SMBIOS within the F-Segment */
+//extern dmibios_entry_point_struct * dmibios_entry_point; /* start of DMIBIOS within the F-Segment */
+extern void * smbios_structures_base; /* base of SMBIOS raw structures */
+extern unsigned char smbios_types_with_subtypes[];
+extern char smbios_version_string[32]; /* e.g. V2.31 */
+/*
+ * Functions
+ */
+
+/* for the description see the implementation file */
+struct smbios_entry_point_struct * smbios_find_entry_point(void * base);
+struct dmibios_entry_point_struct * dmibios_find_entry_point(void * base);
+unsigned char smbios_check_entry_point(void * addr);
+int smbios_type_has_subtype(unsigned char type);
+int smbios_get_struct_length(struct smbios_struct * struct_ptr);
+int dmibios_get_struct_length(struct smbios_struct * struct_ptr);
+unsigned int smbios_get_readable_name_ext(char *readable_name, struct smbios_struct *struct_ptr);
+unsigned int smbios_get_readable_name(char *readable_name, struct smbios_struct *struct_ptr);
+int smbios_check_if_have_exar_config(unsigned char *config0,unsigned char *config1);
+
+
+#endif /* __BIOS_H__ */
* from www.exar.com that will work with kernel versions 2.6.18 to 3.4.x.
*
* ChangeLog:
- * Version 1A - Initial released version.
+ * Version 1B - Initial released version.
*/
-//#undef DEBUG
+#undef DEBUG
#undef VERBOSE_DEBUG
-
+#include <linux/gpio.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/usb/cdc.h>
+#include <linux/dmi.h>
#include <asm/byteorder.h>
#include <asm/unaligned.h>
#include <linux/list.h>
+#include <linux/delay.h>
+#include <asm/io.h> /* ioremap() */
#include "linux/version.h"
+#include "xr_get_smbios.h"
#include "xr_usb_serial_common.h"
#include "xr_usb_serial_ioctl.h"
+
#define DRIVER_AUTHOR "<uarttechsupport@exar.com>"
#define DRIVER_DESC "Exar USB UART (serial port) driver"
static DEFINE_MUTEX(xr_usb_serial_table_lock);
+
+
+
+
/*
* xr_usb_serial_table accessors
*/
return retval < 0 ? retval : 0;
}
+#include "xr_get_smbios.c"
#include "xr_usb_serial_hal.c"
}
static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
-
-static ssize_t set_rs485_422_en(struct device *dev,
- struct device_attribute *attr, const char *buf,
- size_t count)
-{
- struct usb_interface *intf = to_usb_interface(dev);
- struct xr_usb_serial *xr_usb_serial = usb_get_intfdata(intf);
- int error, value = 0;
-
- error = kstrtoint(buf, 0, &value);
- if (error)
- return error;
-
- if (value == 0) {
- xr_usb_serial->rs485_422_en = false;
- } else if (value == 1) {
- // RS485,RS422 HD/FD mode
- xr_usb_serial->rs485_422_en = true;
- }
-
- return count;
-}
-
-static ssize_t show_rs485_422_en(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct usb_interface *intf = to_usb_interface(dev);
- struct xr_usb_serial *xr_usb_serial = usb_get_intfdata(intf);
-
- if (xr_usb_serial->rs485_422_en == false) {
- return sprintf(buf, "0");
- } else if (xr_usb_serial->rs485_422_en == true) {
- // RS485,RS422 HD/FD mode
- return sprintf(buf, "1");
- }
- return 0;
-}
-
-static DEVICE_ATTR(bRS485_422_en, 0644, show_rs485_422_en, set_rs485_422_en);
-
/*
* Interrupt handlers for various XR_USB_SERIAL device responses
*/
{
struct xr_usb_serial *xr_usb_serial = urb->context;
struct usb_cdc_notification *dr = urb->transfer_buffer;
- struct tty_struct *tty;
+#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 9, 0)
+#else
+ struct tty_struct *tty;
+#endif
unsigned char *data;
int newctrl;
int retval;
switch (status) {
case 0:
p = (unsigned char *)(urb->transfer_buffer);
+ /*
for(i=0;i<urb->actual_length;i++)
{
dev_dbg(&xr_usb_serial->control->dev,"0x%02x\n",p[i]);
- }
+ }*/
/* success */
break;
case -ECONNRESET:
}
#endif
xr_usb_serial->ctrlin = newctrl;
-
+ #if 0
dev_dbg(&xr_usb_serial->control->dev,
"%s - input control lines: dcd%c dsr%c break%c "
"ring%c framing%c parity%c overrun%c\n",
xr_usb_serial->ctrlin & XR_USB_SERIAL_CTRL_FRAMING ? '+' : '-',
xr_usb_serial->ctrlin & XR_USB_SERIAL_CTRL_PARITY ? '+' : '-',
xr_usb_serial->ctrlin & XR_USB_SERIAL_CTRL_OVERRUN ? '+' : '-');
+ #endif
break;
default:
if (!test_and_clear_bit(index, &xr_usb_serial->read_urbs_free))
return 0;
- dev_vdbg(&xr_usb_serial->data->dev, "%s - urb %d\n", __func__, index);
+ //dev_vdbg(&xr_usb_serial->data->dev, "%s - urb %d\n", __func__, index);
res = usb_submit_urb(xr_usb_serial->read_urbs[index], mem_flags);
if (res) {
}
static void xr_usb_serial_process_read_urb(struct xr_usb_serial *xr_usb_serial, struct urb *urb)
{
- struct tty_struct *tty;
+#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 9, 0)
+#else
+ struct tty_struct *tty;
+#endif
+ int preciseflags = xr_usb_serial->preciseflags;
+ int have_extra_byte;
+ int length;
+
if (!urb->actual_length)
return;
-#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 9, 0)
+
+ if (preciseflags)
+ {
+ char *dp = urb->transfer_buffer;
+ int i, ch, ch_flags;
+
+ length = urb->actual_length;
+ length = length + (xr_usb_serial->have_extra_byte ? 1 : 0);
+ have_extra_byte = (preciseflags && (length & 1));
+ length = (preciseflags) ? (length / 2) : length;
+ for (i = 0; i < length; ++i)
+ {
+ char tty_flag;
+ if (i == 0)
+ {
+ if (xr_usb_serial->have_extra_byte)
+ {
+ ch = xr_usb_serial->extra_byte;
+ }
+ else
+ {
+ ch = *dp++;
+ }
+ }
+ else
+ {
+ ch = *dp++;
+ }
+ ch_flags = *dp++;
+ if (ch_flags & RAMCTL_BUFFER_PARITY)
+ tty_flag = TTY_PARITY;
+ else if (ch_flags & RAMCTL_BUFFER_BREAK)
+ tty_flag = TTY_BREAK;
+ else if (ch_flags & RAMCTL_BUFFER_FRAME)
+ tty_flag = TTY_FRAME;
+ else if (ch_flags & RAMCTL_BUFFER_OVERRUN)
+ tty_flag = TTY_OVERRUN;
+ else
+ tty_flag = TTY_NORMAL;
+
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0)
+ tty_insert_flip_char(&xr_usb_serial->port, ch, tty_flag);
+ tty_flip_buffer_push(&xr_usb_serial->port);
+#else
+ tty = tty_port_tty_get(&xr_usb_serial->port);
+ if (!tty)
+ return;
+ tty_insert_flip_char(&xr_usb_serial->port, ch, tty_flag);
+ tty_flip_buffer_push(tty);
+
+ tty_kref_put(tty);
+#endif
+
+ }
+ }
+ else
+ {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0)
tty_insert_flip_string(&xr_usb_serial->port, urb->transfer_buffer,
urb->actual_length);
tty_flip_buffer_push(&xr_usb_serial->port);
tty_kref_put(tty);
#endif
+ }
}
static void xr_usb_serial_read_bulk_callback(struct urb *urb)
struct xr_usb_serial_rb *rb = urb->context;
struct xr_usb_serial *xr_usb_serial = rb->instance;
unsigned long flags;
-
+ /*
dev_vdbg(&xr_usb_serial->data->dev, "%s - urb %d, len %d\n", __func__,
- rb->index, urb->actual_length);
+ rb->index, urb->actual_length);*/
+
set_bit(rb->index, &xr_usb_serial->read_urbs_free);
if (!xr_usb_serial->dev) {
if (urb->status) {
dev_dbg(&xr_usb_serial->data->dev, "%s - non-zero urb status: %d\n",
__func__, urb->status);
- return;
+ //return;
}
xr_usb_serial_process_read_urb(xr_usb_serial, urb);
static void xr_usb_serial_softint(struct work_struct *work)
{
struct xr_usb_serial *xr_usb_serial = container_of(work, struct xr_usb_serial, work);
- struct tty_struct *tty;
+#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 9, 0)
+#else
+ struct tty_struct *tty;
+#endif
+
- dev_vdbg(&xr_usb_serial->data->dev, "%s\n", __func__);
+ //dev_vdbg(&xr_usb_serial->data->dev, "%s\n", __func__);
#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 9, 0)
tty_port_tty_wakeup(&xr_usb_serial->port);
#else
struct xr_usb_serial *xr_usb_serial;
int retval;
- dev_dbg(tty->dev, "%s\n", __func__);
+ //dev_dbg(tty->dev, "%s\n", __func__);
xr_usb_serial = xr_usb_serial_get_by_index(tty->index);
if (!xr_usb_serial)
static int xr_usb_serial_tty_open(struct tty_struct *tty, struct file *filp)
{
struct xr_usb_serial *xr_usb_serial = tty->driver_data;
-
- dev_dbg(tty->dev, "%s\n", __func__);
-
+ int result;
+ result = xr_usb_serial_fifo_reset(xr_usb_serial);
+ //dev_dbg(tty->dev, "%s\n", __func__);
+
return tty_port_open(&xr_usb_serial->port, tty, filp);
}
struct xr_usb_serial *xr_usb_serial = container_of(port, struct xr_usb_serial, port);
int retval = -ENODEV;
- dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
+ //dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
mutex_lock(&xr_usb_serial->mutex);
if (xr_usb_serial->disconnected)
{
struct xr_usb_serial *xr_usb_serial = container_of(port, struct xr_usb_serial, port);
- dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
+ //dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
tty_unregister_device(xr_usb_serial_tty_driver, xr_usb_serial->minor);
#endif
+#ifdef CONFIG_GPIOLIB
+ gpiochip_remove(&xr_usb_serial->xr_usb_gpio);
+#endif
xr_usb_serial_release_minor(xr_usb_serial);
usb_put_intf(xr_usb_serial->control);
kfree(xr_usb_serial->country_codes);
kfree(xr_usb_serial);
+
}
static void xr_usb_serial_port_shutdown(struct tty_port *port)
struct xr_usb_serial *xr_usb_serial = container_of(port, struct xr_usb_serial, port);
int i;
- dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
+ //dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
mutex_lock(&xr_usb_serial->mutex);
if (!xr_usb_serial->disconnected) {
static void xr_usb_serial_tty_cleanup(struct tty_struct *tty)
{
struct xr_usb_serial *xr_usb_serial = tty->driver_data;
- dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
+ //dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
tty_port_put(&xr_usb_serial->port);
}
static void xr_usb_serial_tty_hangup(struct tty_struct *tty)
{
struct xr_usb_serial *xr_usb_serial = tty->driver_data;
- dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
+ //dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
tty_port_hangup(&xr_usb_serial->port);
}
static void xr_usb_serial_tty_close(struct tty_struct *tty, struct file *filp)
{
struct xr_usb_serial *xr_usb_serial = tty->driver_data;
- dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
+ //dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
tty_port_close(&xr_usb_serial->port, tty, filp);
}
if (!count)
return 0;
- dev_vdbg(&xr_usb_serial->data->dev, "%s - count %d\n", __func__, count);
+ //dev_vdbg(&xr_usb_serial->data->dev, "%s - count %d\n", __func__, count);
spin_lock_irqsave(&xr_usb_serial->write_lock, flags);
wbn = xr_usb_serial_wb_alloc(xr_usb_serial);
}
count = (count > xr_usb_serial->writesize) ? xr_usb_serial->writesize : count;
- dev_vdbg(&xr_usb_serial->data->dev, "%s - write %d\n", __func__, count);
+ //dev_vdbg(&xr_usb_serial->data->dev, "%s - write %d\n", __func__, count);
memcpy(wb->buf, buf, count);
wb->len = count;
retval = xr_usb_serial_send_break(xr_usb_serial, state ? 0xffff : 0);
if (retval < 0)
- dev_dbg(&xr_usb_serial->control->dev, "%s - send break failed\n",
+ dev_err(&xr_usb_serial->control->dev, "%s - send break failed\n",
__func__);
return retval;
}
static int xr_usb_serial_tty_tiocmget(struct tty_struct *tty)
{
struct xr_usb_serial *xr_usb_serial = tty->driver_data;
- dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_tty_tiocmget\n");
+ //dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_tty_tiocmget\n");
return xr_usb_serial_tiocmget(xr_usb_serial);
}
unsigned int set, unsigned int clear)
{
struct xr_usb_serial *xr_usb_serial = tty->driver_data;
- dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_tty_tiocmset set=0x%x clear=0x%x\n",set,clear);
+ //dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_tty_tiocmset set=0x%x clear=0x%x\n",set,clear);
return xr_usb_serial_tiocmset(xr_usb_serial,set,clear);
}
{
struct xr_usb_serial *xr_usb_serial = tty->driver_data;
int rv = -ENOIOCTLCMD;
- unsigned int channel, reg, val;
-
+ unsigned int channel, reg, val,preciseflags;
+ int baud_rate = 0;
+ struct usb_cdc_line_coding newline;
short *data;
switch (cmd) {
case TIOCGSERIAL: /* gets serial port data */
{
rv = xr_usb_serial_get_reg_ext(xr_usb_serial,channel,reg, data);
}
- if (rv != 1) {
+ if (rv < 0)
+ {
dev_err(&xr_usb_serial->control->dev, "Cannot get register (%d)\n", rv);
kfree(data);
return -EFAULT;
return -EFAULT;
rv = 0;
break;
+ case XR_USB_SERIAL_SET_GPIO_MODE_REG:
+ xr_usb_serial_disable(xr_usb_serial);
+ if (get_user(channel, (int __user *)arg))
+ return -EFAULT;
+ if (get_user(val, (int __user *)(arg + sizeof(int))))
+ return -EFAULT;
+ if (channel == -1)
+ {
+ //block = portdata->block;
+ rv = xr_usb_serial_set_reg(xr_usb_serial,xr_usb_serial->reg_map.uart_gpio_mode_addr, val);
+ }
+ else
+ {
+ rv = xr_usb_serial_set_reg_ext(xr_usb_serial,channel,xr_usb_serial->reg_map.uart_gpio_mode_addr, val);
+ }
+
+ dev_dbg(&xr_usb_serial->control->dev, "XR_USB_SERIAL_SET_GPIO_MODE_REG 0x%x val:0x%x \n", xr_usb_serial->reg_map.uart_gpio_mode_addr,val);
+ xr_usb_serial_enable(xr_usb_serial);
+ if (rv < 0)
+ return -EFAULT;
+ break;
+ case XR_USB_SERIAL_GET_GPIO_MODE_REG:
+ xr_usb_serial_disable(xr_usb_serial);
+ if (get_user(channel, (int __user *)arg))
+ return -EFAULT;
+
+ data = kmalloc(2, GFP_KERNEL);
+ if (data == NULL) {
+ dev_err(&xr_usb_serial->control->dev, "%s - Cannot allocate USB buffer.\n", __func__);
+ return -ENOMEM;
+ }
+
+ if (channel == -1)
+ {
+ rv = xr_usb_serial_get_reg(xr_usb_serial,xr_usb_serial->reg_map.uart_gpio_mode_addr, data);
+ }
+ else
+ {
+ rv = xr_usb_serial_get_reg_ext(xr_usb_serial,channel,xr_usb_serial->reg_map.uart_gpio_mode_addr,data);
+ }
+
+ xr_usb_serial_enable(xr_usb_serial);
+
+ dev_dbg(&xr_usb_serial->control->dev, "XR_USB_SERIAL_GET_GPIO_MODE_REG 0x%x val:0x%x \n", xr_usb_serial->reg_map.uart_gpio_mode_addr,*data);
+
+ if (rv < 0 ) {
+ dev_err(&xr_usb_serial->control->dev, "Cannot get register (%d) channel=%d \n", rv,channel);
+ kfree(data);
+ return -EFAULT;
+ }
+
+ if (put_user(data[0], (int __user *)(arg + sizeof(int)))) {
+ dev_err(&xr_usb_serial->control->dev, "Cannot put user result\n");
+ kfree(data);
+ return -EFAULT;
+ }
+
+ kfree(data);
+ break;
+ case XRIOC_SET_ANY_BAUD_RATE:
+
+ if (get_user(baud_rate, (int __user *)arg)) {
+ dev_dbg(&xr_usb_serial->control->dev, "get_user errot \n");
+ return -EFAULT;
+ }
+ xr_usb_serial->line.dwDTERate = baud_rate;
+ memcpy(&newline,&(xr_usb_serial->line),sizeof(struct usb_cdc_line_coding));
+ xr_usb_serial_disable(xr_usb_serial);
+ rv = xr_usb_serial_set_line(xr_usb_serial,&newline);
+ xr_usb_serial_enable(xr_usb_serial);
+ dev_dbg(&xr_usb_serial->control->dev, "XRIOC_SET_ANY_BAUD_RATE set baud_rate:%d ret=%d\n", baud_rate,rv);
+ break;
+ case XRIOC_SET_PRECISE_FLAGS:
+ preciseflags = arg;
+ dev_dbg(&xr_usb_serial->control->dev, "%s VIOC_SET_PRECISE_FLAGS %d\n", __func__, preciseflags);
+ xr_usb_serial_disable(xr_usb_serial);
+ if (preciseflags)
+ {
+ xr_usb_serial->preciseflags = 1;
+ }
+ else
+ {
+ xr_usb_serial->preciseflags = 0;
+ }
+ xr_usb_serial_set_wide_mode(xr_usb_serial,xr_usb_serial->preciseflags);
+ xr_usb_serial_enable(xr_usb_serial);
+ break;
}
newline.bParityType = termios->c_cflag & PARENB ?
(termios->c_cflag & PARODD ? 1 : 2) +
(termios->c_cflag & CMSPAR ? 2 : 0) : 0;
+ xr_usb_serial->trans9 = 0;
switch (termios->c_cflag & CSIZE) {
case CS5:/*using CS5 replace of the 9 bit data mode*/
newline.bDataBits = 9;
+ xr_usb_serial->trans9 =1;
break;
case CS6:
newline.bDataBits = 6;
xr_usb_serial_set_control(xr_usb_serial, xr_usb_serial->ctrlout = newctrl);
xr_usb_serial_set_flow_mode(xr_usb_serial,tty,cflag);/*set the serial flow mode*/
-
+ if (xr_usb_serial->trans9)
+ {
+ /* Turn on wide mode if we're 9-bit transparent. */
+ xr_usb_serial_set_wide_mode(xr_usb_serial,1);
+ }
+ else if (!xr_usb_serial->preciseflags)
+ {
+ xr_usb_serial_set_wide_mode(xr_usb_serial,0);
+ }
+
+
if (memcmp(&xr_usb_serial->line, &newline, sizeof newline))
{
memcpy(&xr_usb_serial->line, &newline, sizeof newline);
+ /*
dev_dbg(&xr_usb_serial->control->dev, "%s - set line: %d %d %d %d\n",
__func__,
le32_to_cpu(newline.dwDTERate),
newline.bCharFormat, newline.bParityType,
- newline.bDataBits);
+ newline.bDataBits);*/
+
xr_usb_serial_set_line(xr_usb_serial, &xr_usb_serial->line);
}
xr_usb_serial_enable(xr_usb_serial);
return 0;
}
+#ifdef CONFIG_GPIOLIB
+static int xr_usb_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+ struct xr_usb_serial *xr_usb_serial = container_of(chip, struct xr_usb_serial, xr_usb_gpio);
+ dev_dbg(chip->dev, "xr_usb_gpio_get offset = %d channel = %d\n",offset,xr_usb_serial->channel);
+ return 0;
+}
+
+static void xr_usb_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
+{
+ struct xr_usb_serial *xr_usb_serial = container_of(chip, struct xr_usb_serial, xr_usb_gpio);
+ dev_dbg(chip->dev, "xr_usb_gpio_set offset =%d val=%d channel = %d\n",offset,val,xr_usb_serial->channel);
+}
+
+static int xr_usb_gpio_direction_input(struct gpio_chip *chip,unsigned offset)
+{
+ struct xr_usb_serial *xr_usb_serial = container_of(chip, struct xr_usb_serial, xr_usb_gpio);
+ dev_dbg(chip->dev, "xr_usb_gpio_direction_input offset =%d channel = %d\n",offset,xr_usb_serial->channel);
+ return 0;
+}
+
+static int xr_usb_gpio_direction_output(struct gpio_chip *chip,
+ unsigned offset, int val)
+{
+ struct xr_usb_serial *xr_usb_serial = container_of(chip, struct xr_usb_serial, xr_usb_gpio);
+ dev_dbg(chip->dev, "xr_usb_gpio_direction_output offset =%d val=%d channel:%d\n",offset,val,xr_usb_serial->channel);
+ return 0;
+}
+#endif
+
static int xr_usb_serial_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : XR_USB_SERIAL_NR;
- dev_dbg(&intf->dev, "USB_device_id idVendor:%04x, idProduct %04x\n",id->idVendor,id->idProduct);
+ //dev_dbg(&intf->dev, "USB_device_id idVendor:%04x, idProduct %04x\n",id->idVendor,id->idProduct);
/* handle quirks deadly to normal probing*/
if (quirks == NO_UNION_NORMAL) {
}
#else
xr_usb_serial->channel = epwrite->bEndpointAddress;
- dev_dbg(&intf->dev, "epwrite->bEndpointAddress =%d\n",epwrite->bEndpointAddress);
+ //dev_dbg(&intf->dev, "epwrite->bEndpointAddress =%d\n",epwrite->bEndpointAddress);
#endif
buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &xr_usb_serial->ctrl_dma);
if (!buf) {
usb_set_intfdata(intf, xr_usb_serial);
- xr_usb_serial->rs485_422_en = false; //default enable rs232
- i = device_create_file(&intf->dev, &dev_attr_bRS485_422_en);
- if (i < 0)
- goto alloc_fail7;
-
i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
if (i < 0)
- goto alloc_fail8;
+ goto alloc_fail7;
if (cfd) { /* export the country data */
xr_usb_serial->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
xr_usb_serial->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
xr_usb_serial->ctrlurb->transfer_dma = xr_usb_serial->ctrl_dma;
- dev_info(&intf->dev, "ttyXR_USB_SERIAL%d: USB XR_USB_SERIAL device\n", minor);
+ //dev_info(&intf->dev, "ttyXR_USB_SERIAL%d: USB XR_USB_SERIAL device channel:%d\n", minor,xr_usb_serial->channel);
xr_usb_serial_pre_setup(xr_usb_serial);
&control_interface->dev);
if (IS_ERR(tty_dev)) {
rv = PTR_ERR(tty_dev);
- goto alloc_fail9;
+ goto alloc_fail8;
}
#endif
-
+#ifdef CONFIG_GPIOLIB
+ /* Setup GPIO cotroller */
+ xr_usb_serial->xr_usb_gpio.owner = THIS_MODULE;
+ xr_usb_serial->xr_usb_gpio.dev = &control_interface->dev;
+ xr_usb_serial->xr_usb_gpio.label = dev_name(&control_interface->dev);
+ xr_usb_serial->xr_usb_gpio.direction_input = xr_usb_gpio_direction_input;
+ xr_usb_serial->xr_usb_gpio.get = xr_usb_gpio_get;
+ xr_usb_serial->xr_usb_gpio.direction_output = xr_usb_gpio_direction_output;
+ xr_usb_serial->xr_usb_gpio.set = xr_usb_gpio_set;
+ xr_usb_serial->xr_usb_gpio.base = 100 + xr_usb_serial->channel*10;
+ xr_usb_serial->xr_usb_gpio.ngpio = 4;
+ xr_usb_serial->xr_usb_gpio.can_sleep = 1;
+ rv = gpiochip_add(&xr_usb_serial->xr_usb_gpio);
+ dev_dbg(&xr_usb_serial->control->dev, "gpiochip_add %d\n",rv);
+#endif
return 0;
-alloc_fail9:
+alloc_fail8:
if (xr_usb_serial->country_codes) {
device_remove_file(&xr_usb_serial->control->dev,
&dev_attr_wCountryCodes);
&dev_attr_iCountryCodeRelDate);
}
device_remove_file(&xr_usb_serial->control->dev, &dev_attr_bmCapabilities);
-alloc_fail8:
- device_remove_file(&xr_usb_serial->control->dev, &dev_attr_bRS485_422_en);
alloc_fail7:
usb_set_intfdata(intf, NULL);
for (i = 0; i < XR_USB_SERIAL_NW; i++)
{
int i;
- dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
+ //dev_dbg(&xr_usb_serial->control->dev, "%s\n", __func__);
usb_kill_urb(xr_usb_serial->ctrlurb);
for (i = 0; i < XR_USB_SERIAL_NW; i++)
struct tty_struct *tty;
int i;
- dev_dbg(&intf->dev, "%s\n", __func__);
+ //dev_dbg(&intf->dev, "%s\n", __func__);
/* sibling interface is already cleaning up */
if (!xr_usb_serial)
&dev_attr_iCountryCodeRelDate);
}
device_remove_file(&xr_usb_serial->control->dev, &dev_attr_bmCapabilities);
- device_remove_file(&xr_usb_serial->control->dev, &dev_attr_bRS485_422_en);
usb_set_intfdata(xr_usb_serial->control, NULL);
usb_set_intfdata(xr_usb_serial->data, NULL);
mutex_unlock(&xr_usb_serial->mutex);
struct xr_usb_serial_wb *wb;
int rv = 0;
int cnt;
-
+
+ xr_usb_serial_pre_setup(xr_usb_serial);
+
spin_lock_irq(&xr_usb_serial->read_lock);
xr_usb_serial->susp_count -= 1;
cnt = xr_usb_serial->susp_count;
static int xr_usb_serial_reset_resume(struct usb_interface *intf)
{
struct xr_usb_serial *xr_usb_serial = usb_get_intfdata(intf);
- struct tty_struct *tty;
+#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 9, 0)
+#else
+ struct tty_struct *tty;
+#endif
if (test_bit(ASYNCB_INITIALIZED, &xr_usb_serial->port.flags)){
#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 9, 0)
tty_port_tty_hangup(&xr_usb_serial->port, false);
.tiocmget = xr_usb_serial_tty_tiocmget,
.tiocmset = xr_usb_serial_tty_tiocmset,
};
-
-/*
- * Init / exit.
- */
-
static int __init xr_usb_serial_init(void)
{
int retval;
+ int i;
+
xr_usb_serial_tty_driver = alloc_tty_driver(XR_USB_SERIAL_TTY_MINORS);
if (!xr_usb_serial_tty_driver)
return -ENOMEM;
put_tty_driver(xr_usb_serial_tty_driver);
return retval;
}
-
+
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
return 0;
}
-
static void __exit xr_usb_serial_exit(void)
{
usb_deregister(&xr_usb_serial_driver);
tty_unregister_driver(xr_usb_serial_tty_driver);
put_tty_driver(xr_usb_serial_tty_driver);
+
}
module_init(xr_usb_serial_init);
#define XR_USB_SERIAL_NW 16
#define XR_USB_SERIAL_NR 16
+#define RAMCTL_BUFFER_PARITY 0x1
+#define RAMCTL_BUFFER_BREAK 0x2
+#define RAMCTL_BUFFER_FRAME 0x4
+#define RAMCTL_BUFFER_OVERRUN 0x8
+
struct xr_usb_serial_wb {
unsigned char *buf;
dma_addr_t dmah;
u8 bInterval;
struct xr_usb_serial_wb *delayed_wb; /* write queued for a device about to be woken */
unsigned int channel;
+ int preciseflags; /* USB: wide mode, TTY: flags per character */
+ int trans9; /* USB: wide mode, serial 9N1 */
+ int have_extra_byte;
+ int extra_byte;
+
unsigned short DeviceVendor;
unsigned short DeviceProduct;
+#ifdef CONFIG_GPIOLIB
+ struct gpio_chip xr_usb_gpio;
+#endif
struct reg_addr_map reg_map;
- bool rs485_422_en;
+ int found_smbios_exar_config;
+ unsigned char channel_config;
};
#define CDC_DATA_INTERFACE_TYPE 0x0a
{
int result;
int channel = 0;
- dev_dbg(&xr_usb_serial->control->dev, "%s Channel:%d 0x%02x = 0x%02x\n", __func__,channel,regnum, value);
+ //dev_info(&xr_usb_serial->control->dev, "%s Channel:%d 0x%02x = 0x%02x\n", __func__,channel,regnum, value);
if((xr_usb_serial->DeviceProduct&0xfff0) == 0x1400)
{
int XR2280xaddr = XR2280x_FUNC_MGR_OFFSET + regnum;
result = -1;
}
if(result < 0)
- dev_dbg(&xr_usb_serial->control->dev, "%s Error:%d\n", __func__,result);
+ dev_err(&xr_usb_serial->control->dev, "%s Error:%d\n", __func__,result);
return result;
{
int result;
int XR2280xaddr = XR2280x_FUNC_MGR_OFFSET + regnum;
- dev_dbg(&xr_usb_serial->control->dev, "%s channel:%d 0x%02x = 0x%02x\n", __func__,channel,regnum, value);
+ //dev_info(&xr_usb_serial->control->dev, "%s channel:%d 0x%02x = 0x%02x\n", __func__,channel,regnum, value);
if((xr_usb_serial->DeviceProduct&0xfff0) == 0x1400)
{
result = usb_control_msg(xr_usb_serial->dev, /* usb device */
result = -1;
}
if(result < 0)
- dev_dbg(&xr_usb_serial->control->dev, "%s Error:%d\n", __func__,result);
+ dev_err(&xr_usb_serial->control->dev, "%s Error:%d\n", __func__,result);
return result;
}
if(result < 0)
- dev_dbg(&xr_usb_serial->control->dev, "%s channel:%d Reg 0x%x Error:%d\n", __func__,channel,regnum,result);
- else
- dev_dbg(&xr_usb_serial->control->dev, "%s channel:%d 0x%x = 0x%04x\n", __func__,channel,regnum, *value);
+ dev_err(&xr_usb_serial->control->dev, "%s channel:%d Reg 0x%x Error:%d\n", __func__,channel,regnum,result);
+ //else
+ //dev_info(&xr_usb_serial->control->dev, "%s channel:%d 0x%x = 0x%04x\n", __func__,channel,regnum, *value);
return result;
®_value, /* data */
1, /* size */
5000); /* timeout */
- dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_get_reg_ext reg:%x\n",reg_value);
+ //dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_get_reg_ext reg:%x\n",reg_value);
*value = reg_value;
}
else if(xr_usb_serial->DeviceProduct == 0x1411)
}
if(result < 0)
- dev_dbg(&xr_usb_serial->control->dev, "%s Error:%d\n", __func__,result);
- else
- dev_dbg(&xr_usb_serial->control->dev, "%s channel:%d 0x%x = 0x%04x\n", __func__,channel,regnum, *value);
+ dev_err(&xr_usb_serial->control->dev, "%s Error:%d\n", __func__,result);
+ //else
+ //dev_info(&xr_usb_serial->control->dev, "%s channel:%d 0x%x = 0x%04x\n", __func__,channel,regnum, *value);
return result;
unsigned int tx_mask = xr21v141x_baud_rates[i].tx;
unsigned int rx_mask = (divisor & 1) ? xr21v141x_baud_rates[i].rx1 : xr21v141x_baud_rates[i].rx0;
- dev_dbg(&xr_usb_serial->control->dev, "Setting baud rate to %d: i=%u div=%u tx=%03x rx=%03x\n", rate, i, divisor, tx_mask, rx_mask);
+ //dev_info(&xr_usb_serial->control->dev, "Setting baud rate to %d: i=%u div=%u tx=%03x rx=%03x\n", rate, i, divisor, tx_mask, rx_mask);
xr_usb_serial_set_reg(xr_usb_serial,UART_CLOCK_DIVISOR_0, (divisor >> 0) & 0xff);
xr_usb_serial_set_reg(xr_usb_serial,UART_CLOCK_DIVISOR_1, (divisor >> 8) & 0xff);
if (cflag & CRTSCTS)
{
- dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_set_flow_mode:hardware\n");
+ //dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_set_flow_mode:hardware\n");
flow = UART_FLOW_MODE_HW;
gpio_mode = UART_GPIO_MODE_SEL_RTS_CTS;
}
{
unsigned char start_char = START_CHAR(tty);
unsigned char stop_char = STOP_CHAR(tty);
- dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_set_flow_mode:software\n");
+ //dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_set_flow_mode:software\n");
flow = UART_FLOW_MODE_SW;
gpio_mode = UART_GPIO_MODE_SEL_GPIO;
}
else
{
- dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_set_flow_mode:none\n");
+ //dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_set_flow_mode:none\n");
flow = UART_FLOW_MODE_NONE;
gpio_mode = UART_GPIO_MODE_SEL_GPIO;
}
- // rs485,rs422 FD/HD mode
- if (xr_usb_serial->rs485_422_en) {
- xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_flow_addr, 0x00);
- xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, 0x0B);
- } else {
- //rs232, default mode
- xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_flow_addr, flow);
- xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, gpio_mode);
+
+ if((xr_usb_serial->DeviceProduct == 0x1420)||
+ (xr_usb_serial->DeviceProduct == 0x1422)||
+ (xr_usb_serial->DeviceProduct == 0x1424))
+ {//Add support for the TXT and RXT function for 0x1420, 0x1422, 0x1424, by setting GPIO_MODE [9:8] = '11'
+ gpio_mode |= 0x300;
+ }
+
+ if((xr_usb_serial->DeviceProduct == 0x1412)||
+ (xr_usb_serial->DeviceProduct == 0x1414))
+ {
+ if(xr_usb_serial->found_smbios_exar_config)
+ {
+ if((xr_usb_serial->channel_config == 2)
+ ||(xr_usb_serial->channel_config == 3))
+ //if find the exar channel config in the smbios, the value can not be changed by the application
+ //dev_info(&xr_usb_serial->control->dev, "Sorry, Application can not change the channel gpio&flow mode,because there are config at SMBIOS\n");
+ return 0;
+ }
+ }
+
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_flow_addr, flow);
+
+ if((xr_usb_serial->found_smbios_exar_config == 1)&&(xr_usb_serial->channel_config == 1))
+ {
+ //dev_info(&xr_usb_serial->control->dev, "Sorry, Application can not change the channel gpio mode,because there are config at SMBIOS\n");
}
+ else
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, gpio_mode);
+
return 0;
}
+
+
+
int xr_usb_serial_send_break(struct xr_usb_serial *xr_usb_serial, int state)
{
#define URM_ENABLE_BASE 0x010
#define URM_ENABLE_0_TX 0x001
#define URM_ENABLE_0_RX 0x002
+#define URM_RESET_RX_FIFO_BASE 0x018
+#define URM_RESET_TX_FIFO_BASE 0x01C
+
+
int xr_usb_serial_enable(struct xr_usb_serial *xr_usb_serial)
{
int ret = 0;
int channel = xr_usb_serial->channel;
+ //dev_info(&xr_usb_serial->control->dev, "xr_usb_serial_enable channel=%d\n",channel);
+ if(channel) channel--;
if((xr_usb_serial->DeviceProduct == 0x1410)||
(xr_usb_serial->DeviceProduct == 0x1412)||
(xr_usb_serial->DeviceProduct == 0x1414))
return ret;
}
+int xr_usb_serial_fifo_reset(struct xr_usb_serial *xr_usb_serial)
+{
+ int ret = 0;
+ int channel = xr_usb_serial->channel;
+
+ if(channel) channel--;
+ if((xr_usb_serial->DeviceProduct == 0x1410)||
+ (xr_usb_serial->DeviceProduct == 0x1412)||
+ (xr_usb_serial->DeviceProduct == 0x1414))
+ {
+
+ ret = xr_usb_serial_set_reg_ext(xr_usb_serial,URM_REG_BLOCK,URM_RESET_RX_FIFO_BASE + channel,0xff);
+ ret |= xr_usb_serial_set_reg_ext(xr_usb_serial,URM_REG_BLOCK,URM_RESET_TX_FIFO_BASE + channel,0xff);
+
+ }
+ return ret;
+}
+
+
int xr_usb_serial_disable(struct xr_usb_serial *xr_usb_serial)
{
int ret = 0;
int channel = xr_usb_serial->channel;
+ //dev_info(&xr_usb_serial->control->dev, "xr_usb_serial_disable channel=%d\n",channel);
+ if(channel) channel--;
ret = xr_usb_serial_set_reg(xr_usb_serial,xr_usb_serial->reg_map.uart_enable_addr,0);
if((xr_usb_serial->DeviceProduct == 0x1410)||
(xr_usb_serial->DeviceProduct == 0x1412)||
{
int ret = 0;
xr_usb_serial_disable(xr_usb_serial);
- ret = xr_usb_serial_set_reg_ext(xr_usb_serial,channel,
+
+ if((xr_usb_serial->DeviceProduct == 0x1410) ||
+ (xr_usb_serial->DeviceProduct == 0x1412) ||
+ (xr_usb_serial->DeviceProduct == 0x1414))
+ {
+ switch (channel)
+ {
+ case 0:
+ ret = xr_usb_serial_set_reg_ext(xr_usb_serial,channel,
+ xr_usb_serial->reg_map.uart_loopback_addr,0x40);
+ break;
+ case 1:
+ ret = xr_usb_serial_set_reg_ext(xr_usb_serial,channel,
+ xr_usb_serial->reg_map.uart_loopback_addr,0x41);
+ break;
+ case 2:
+ ret = xr_usb_serial_set_reg_ext(xr_usb_serial,channel,
+ xr_usb_serial->reg_map.uart_loopback_addr,0x42);
+ break;
+ case 3:
+ ret = xr_usb_serial_set_reg_ext(xr_usb_serial,channel,
+ xr_usb_serial->reg_map.uart_loopback_addr,0x43);
+ break;
+ default:
+
+ break;
+ }
+ }
+ else if((xr_usb_serial->DeviceProduct == 0x1420)||
+ (xr_usb_serial->DeviceProduct == 0x1422)||
+ (xr_usb_serial->DeviceProduct == 0x1424))
+ {
+ ret = xr_usb_serial_set_reg_ext(xr_usb_serial,channel,
xr_usb_serial->reg_map.uart_loopback_addr,0x07);
+ }
xr_usb_serial_enable(xr_usb_serial);
return ret;
}
+#define XR21V1414_WIDE_MODE_OFFSET 3
+#define XR21B142X_WIDE_MODE_TX_OFFSET 0x42
+#define XR21B142X_WIDE_MODE_RX_OFFSET 0x45
+int xr_usb_serial_set_wide_mode(struct xr_usb_serial *xr_usb_serial, int preciseflags)
+{
+ int ret = 0;
+ int channel = xr_usb_serial->channel;
+ xr_usb_serial_disable(xr_usb_serial);
+ if((xr_usb_serial->DeviceProduct&0xfff0) == 0x1400)
+ {
+
+ }
+ else if((xr_usb_serial->DeviceProduct == 0x1410)||
+ (xr_usb_serial->DeviceProduct == 0x1412)||
+ (xr_usb_serial->DeviceProduct == 0x1414))
+ {
+
+ if(channel) channel--;
+ xr_usb_serial_set_reg_ext(xr_usb_serial, 0x66, channel*8 + XR21V1414_WIDE_MODE_OFFSET, preciseflags);
+
+ }
+ else if(xr_usb_serial->DeviceProduct == 0x1411)
+ {
+ xr_usb_serial_set_reg(xr_usb_serial,0xd02, preciseflags);
+ }
+ else if((xr_usb_serial->DeviceProduct == 0x1420)||
+ (xr_usb_serial->DeviceProduct == 0x1422)||
+ (xr_usb_serial->DeviceProduct == 0x1424))
+ {
+ xr_usb_serial_set_reg(xr_usb_serial, XR21B142X_WIDE_MODE_TX_OFFSET, preciseflags);
+ xr_usb_serial_set_reg(xr_usb_serial, XR21B142X_WIDE_MODE_RX_OFFSET, preciseflags);
+ }
+ xr_usb_serial_enable(xr_usb_serial);
+ return ret;
+}
+
static int xr_usb_serial_tiocmget(struct xr_usb_serial *xr_usb_serial)
short data;
int result;
result = xr_usb_serial_get_reg(xr_usb_serial,xr_usb_serial->reg_map.uart_gpio_status_addr, &data);
- dev_dbg(&xr_usb_serial->control->dev, "xr_usb_serial_tiocmget uart_gpio_status_addr:0x%04x\n",data);
+ //dev_info(&xr_usb_serial->control->dev, "xr_usb_serial_tiocmget uart_gpio_status_addr:0x%04x\n",data);
if (result)
return ((data & 0x8) ? 0: TIOCM_DTR) | ((data & 0x20) ? 0:TIOCM_RTS ) | ((data & 0x4) ? 0:TIOCM_DSR) | ((data & 0x1) ? 0 : TIOCM_RI) | ((data & 0x2) ? 0:TIOCM_CD) | ((data & 0x10) ? 0 : TIOCM_CTS);
else
xr21b140x_reg_map.uart_custom_driver = 0x60;
xr21b140x_reg_map.uart_low_latency = 0x46;
}
-
+int smbios_check_if_have_exar_config(unsigned char *config0,unsigned char *config1);
int xr_usb_serial_pre_setup(struct xr_usb_serial *xr_usb_serial)
{
int ret = 0;
-
+ unsigned char channel1_config = 255;
+ unsigned char channel2_config = 255;
init_xr21b140x_reg_map();
init_xr21b1411_reg_map();
init_xr21v141x_reg_map();
xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_dir_addr, 0x28);
xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_set_addr, UART_GPIO_SET_DTR | UART_GPIO_SET_RTS);
+ if((xr_usb_serial->DeviceProduct == 0x1412)||
+ (xr_usb_serial->DeviceProduct == 0x1414))
+ {
+ xr_usb_serial->found_smbios_exar_config = 0;
+ if(smbios_check_if_have_exar_config(&channel1_config,&channel2_config) == 0)
+ {
+
+ if(xr_usb_serial->channel == 1)
+ {
+ xr_usb_serial->found_smbios_exar_config = 1;
+ xr_usb_serial->channel_config = channel1_config;
+ switch (channel1_config)
+ {
+ case 1://for RS232 Mode
+ //dev_info(&xr_usb_serial->control->dev, "SMBIOS Set Channel Mode to RS232\n");
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, 0);
+
+ break;
+ case 2://RS-485 HALF DUPLEX
+ //dev_info(&xr_usb_serial->control->dev, "SMBIOS Set Channel Mode to RS-485 HALF DUPLEX\n");
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, 0x0b);
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_flow_addr, 0x00);
+ break;
+ case 3://RS-485/422 FULL DUPLEX
+ //dev_info(&xr_usb_serial->control->dev, "SMBIOS Set Channel Mode to RS-485/422 FULL DUPLEX\n");
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, 0x0b);
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_flow_addr, 0x00);
+ break;
+ default:
+ xr_usb_serial->found_smbios_exar_config = 0;
+ break;
+ }
+
+ }
+ else if(xr_usb_serial->channel == 2)
+ {
+ xr_usb_serial->found_smbios_exar_config = 1;
+ xr_usb_serial->channel_config = channel2_config;
+ switch (channel2_config)
+ {
+ case 1://for RS232 Mode
+ //dev_info(&xr_usb_serial->control->dev, "SMBIOS Set Channel Mode to RS232\n");
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, 0);
+
+ break;
+ case 2://RS-485 HALF DUPLEX
+ //dev_info(&xr_usb_serial->control->dev, "SMBIOS Set Channel Mode to RS-485 HALF DUPLEX\n");
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, 0x0b);
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_flow_addr, 0x00);
+ break;
+ case 3://RS-485/422 FULL DUPLEX
+ //dev_info(&xr_usb_serial->control->dev, "SMBIOS Set Channel Mode to RS-485/422 FULL DUPLEX\n");
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_gpio_mode_addr, 0x0b);
+ xr_usb_serial_set_reg(xr_usb_serial, xr_usb_serial->reg_map.uart_flow_addr, 0x00);
+ break;
+ default:
+ xr_usb_serial->found_smbios_exar_config = 0;
+ break;
+ }
+ }
+ else
+ {
+ //Nothing to do
+ }
+ }
+
+ }
return ret;
}
-
-
#define XR_USB_SERIAL_SET_PRECISE_FLAGS _IO(XR_USB_SERIAL_IOC_MAGIC, 4)
#define XR_USB_SERIAL_TEST_MODE _IO(XR_USB_SERIAL_IOC_MAGIC, 5)
#define XR_USB_SERIAL_LOOPBACK _IO(XR_USB_SERIAL_IOC_MAGIC, 6)
+#define XR_USB_SERIAL_SET_GPIO_MODE_REG _IO(XR_USB_SERIAL_IOC_MAGIC, 9)
+#define XR_USB_SERIAL_GET_GPIO_MODE_REG _IO(XR_USB_SERIAL_IOC_MAGIC, 10)
+#define XRIOC_SET_ANY_BAUD_RATE _IO(XR_USB_SERIAL_IOC_MAGIC, 11)
+#define XRIOC_SET_PRECISE_FLAGS _IO(XR_USB_SERIAL_IOC_MAGIC, 12)
+
+
+
#define VZ_ADDRESS_UNICAST_S 0
#define VZ_ADDRESS_BROADCAST_S 8
projects / mirror_ubuntu-bionic-kernel.git / commitdiff