RFID.rar_c++ usb串口_linux rfid_rfid linux

/* * REINER SCT rfid pinpad/e-com USB Chipcard Reader Driver * * Copyright (C) 2001 REINER SCT * Author: Matthias Bruestle * * Contact: support@reiner-sct.com (see MAINTAINERS) * * This program is largely derived from work by the linux-usb group * and associated source files. Please see the usb/serial files for * individual credits and copyrights. * * 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. * * Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and * patience. * * In case of problems, please write to the contact e-mail address * mentioned above. * * Please note that later models of the rfid reader family are * supported by a libusb-based userspace device driver. * * Homepage: http://www.reiner-sct.de/support/treiber_rfid.php#linux */ #include <linux/kernel.h> #include <linux/errno.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/tty.h> #include <linux/tty_driver.h> #include <linux/tty_flip.h> #include <linux/module.h> #include <linux/spinlock.h> #include <linux/uaccess.h> #include <linux/usb.h> #include <linux/usb/serial.h> #define rfid_LOCAL_BUF_SIZE 32 static int debug; /* * Version Information */ #define DRIVER_VERSION "v1.01" #define DRIVER_AUTHOR "Matthias Bruestle" #define DRIVER_DESC "REINER SCT rfid pinpad/e-com USB Chipcard Reader Driver" #define rfid_VENDOR_ID 0x10c4 #define rfid_PRODUCT_ID 0xea60 /* Function prototypes */ static int rfid_startup(struct usb_serial *serial); static void rfid_disconnect(struct usb_serial *serial); static void rfid_release(struct usb_serial *serial); static int rfid_open(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp); static void rfid_close(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp); static int rfid_write(struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count); static int rfid_write_room(struct tty_struct *tty); static void rfid_read_int_callback(struct urb *urb); static void rfid_read_bulk_callback(struct urb *urb); static void rfid_write_bulk_callback(struct urb *urb); static struct usb_device_id id_table [] = { { USB_DEVICE(rfid_VENDOR_ID, rfid_PRODUCT_ID) }, { } /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, id_table); static struct usb_driver rfid_driver = { .name = "rfid", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, .no_dynamic_id = 1, }; static struct usb_serial_driver rfid_device = { .driver = { .owner = THIS_MODULE, .name = "rfid", }, .description = "Reiner SCT rfid USB card reader", .usb_driver = &rfid_driver, .id_table = id_table, .num_ports = 1, .attach = rfid_startup, .disconnect = rfid_disconnect, .release = rfid_release, .open = rfid_open, .close = rfid_close, .write = rfid_write, .write_room = rfid_write_room, .read_int_callback = rfid_read_int_callback, .read_bulk_callback = rfid_read_bulk_callback, .write_bulk_callback = rfid_write_bulk_callback, }; struct rfid_private { spinlock_t lock; /* Lock for SMP */ short rdtodo; /* Bytes still to read */ unsigned char wrbuf[5*64]; /* Buffer for collecting data to write */ short wrfilled; /* Overall data size we already got */ short wrsent; /* Data already sent */ }; /* do some startup allocations not currently performed by usb_serial_probe() */ static int rfid_startup(struct usb_serial *serial) { struct rfid_private *priv; int i; dbg("%s", __func__); /* allocate the private data structure */ priv = kmalloc(sizeof(struct rfid_private), GFP_KERNEL); if (!priv) return -ENOMEM; /* set initial values */ spin_lock_init(&priv->lock); priv->rdtodo = 0; priv->wrfilled = 0; priv->wrsent = 0; usb_set_serial_port_data(serial->port[0], priv); init_waitqueue_head(&serial->port[0]->write_wait); for (i = 0; i < serial->num_ports; ++i) { int result; serial->port[i]->interrupt_in_urb->dev = serial->dev; result = usb_submit_urb(serial->port[i]->interrupt_in_urb, GFP_KERNEL); if (result) dev_err(&serial->dev->dev, "usb_submit_urb(read int) failed\n"); dbg("%s - usb_submit_urb(int urb)", __func__); } return 0; } static void rfid_disconnect(struct usb_serial *serial) { int i; dbg("%s", __func__); for (i = 0; i < serial->num_ports; ++i) usb_kill_urb(serial->port[i]->interrupt_in_urb); } static void rfid_release(struct usb_serial *serial) { int i; dbg("%s", __func__); for (i = 0; i < serial->num_ports; ++i) { /* My special items, the standard routines free my urbs */ kfree(usb_get_serial_port_data(serial->port[i])); } } static int rfid_open(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp) { struct rfid_private *priv; unsigned long flags; int result = 0; dbg("%s - port %d", __func__, port->number); dbg("%s - usb_clear_halt", __func__); usb_clear_halt(port->serial->dev, port->write_urb->pipe); priv = usb_get_serial_port_data(port); spin_lock_irqsave(&priv->lock, flags); priv->rdtodo = 0; priv->wrfilled = 0; priv->wrsent = 0; spin_unlock_irqrestore(&priv->lock, flags); return result; } static void rfid_close(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp) { dbg("%s - port %d", __func__, port->number); if (port->serial->dev) { /* shutdown any bulk reads that might be going on */ usb_kill_urb(port->write_urb); usb_kill_urb(port->read_urb); } } static int rfid_write(struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count) { struct usb_serial *serial = port->serial; struct rfid_private *priv = usb_get_serial_port_data(port); unsigned long flags; int result; int wrexpected; dbg("%s - port %d", __func__, port->number); if (count == 0) { dbg("%s - write request of 0 bytes", __func__); return 0; } spin_lock_bh(&port->lock); if (port->write_urb_busy) { spin_unlock_bh(&port->lock); dbg("%s - already writing", __func__); return 0; } port->write_urb_busy = 1; spin_unlock_bh(&port->lock); spin_lock_irqsave(&priv->lock, flags); if (count+priv->wrfilled > sizeof(priv->wrbuf)) { /* To much data for buffer. Reset buffer. */ priv->wrfilled = 0; port->write_urb_busy = 0; spin_unlock_irqrestore(&priv->lock, flags); return 0; } /* Copy data */ memcpy(priv->wrbuf + priv->wrfilled, buf, count); usb_serial_debug_data(debug, &port->dev, __func__, count, priv->wrbuf + priv->wrfilled); priv->wrfilled += count; if (priv->wrfilled >= 3) { wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3; dbg("%s - expected data: %d", __func__, wrexpected); } else wrexpected = sizeof(priv->wrbuf); if (priv->wrfilled >= wrexpected) { /* We have enough data to begin transmission */ int length; dbg("%s - transmitting data (frame 1)", __func__); length = (wrexpected > port->bulk_out_size) ? port->bulk_out_size : wrexpected; memcpy(port->write_urb->transfer_buffer, priv->wrbuf, length); priv->wrsent = length; /* set up our urb */ usb_fill_bulk_urb(port->write_urb, serial->dev, usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress), port->write_urb->transfer_buffer, length, ((serial->type->write_bulk_callback) ? serial->type->write_bulk_callback : rfid_write_bulk_callback), port); /* send the data out the bulk port */ result = usb_submit_urb(port->write_urb, GFP_ATOMIC); if (result) { dev_err(&port->dev, "%s - failed submitting write urb, error %d", __func__, result); /* Throw away data. No better idea what to do with it. */ priv->wrfilled = 0; priv->wrsent = 0; spin_unlock_irqrestore(&priv->lock, flags); port->write_urb_busy = 0; return 0; } dbg("%s - priv->wrsent=%d",