haiku.git

/*
 * Copyright 2009-2010, François Revol, <revol@free.fr>.
 * Sponsored by TuneTracker Systems.
 * Based on the Haiku usb_serial driver which is:
 *
 * Copyright (c) 2007-2008 by Michael Lotz
 * Heavily based on the original usb_serial driver which is:
 *
 * Copyright (c) 2003 by Siarzhuk Zharski <imker@gmx.li>
 * Distributed under the terms of the MIT License.
 */
#ifndef _SERIAL_DEVICE_H_
#define _SERIAL_DEVICE_H_

#include "Driver.h"

class SerialDevice {
public:
								SerialDevice(const struct serial_support_descriptor
									*device, uint32 ioBase, uint32 irq, const SerialDevice *master=NULL);
virtual							~SerialDevice();

		bool					Probe();

static	SerialDevice *			MakeDevice(struct serial_config_descriptor
									*device);

		status_t				Init();

		const struct serial_support_descriptor	*SupportDescriptor() const
									{ return fSupportDescriptor; };
		struct serial_config_descriptor	*ConfigDescriptor() const
									{ return fDevice; };
		//uint16					ProductID() const { return fProductID; };
		//uint16					VendorID() const { return fVendorID; };
		const char *			Description() const { return fDescription; };

		const SerialDevice *	Master() const { return fMaster ? fMaster : this; };

		char *					ReadBuffer() { return fReadBuffer; };

		char *					WriteBuffer() { return fWriteBuffer; };

		void					SetModes(struct termios *tios);

		bool					Service(struct tty *tty, uint32 op,
									void *buffer, size_t length);

		bool					IsInterruptPending();
		int32					InterruptHandler();

		status_t				Open(uint32 flags);
		status_t				Read(char *buffer, size_t *numBytes);
		status_t				Write(const char *buffer, size_t *numBytes);
		status_t				Control(uint32 op, void *arg, size_t length);
		status_t				Select(uint8 event, uint32 ref, selectsync *sync);
		status_t				DeSelect(uint8 event, selectsync *sync);
		status_t				Close();
		status_t				Free();

		bool					IsOpen() { return fDeviceOpen; };
		void					Removed();
		bool					IsRemoved() { return fDeviceRemoved; };

		/* virtual interface to be overriden as necessary */
virtual	status_t				AddDevice(const struct serial_config_descriptor *device);

virtual	status_t				ResetDevice();

//virtual	status_t				SetLineCoding(usb_serial_line_coding *coding);
//virtual	status_t				SetControlLineState(uint16 state);
virtual	status_t				SignalControlLineState(int line, bool enable);

virtual	void					OnRead(char **buffer, size_t *numBytes);
virtual	void					OnWrite(const char *buffer, size_t *numBytes,
									size_t *packetBytes);
virtual	void					OnClose();

		uint32					IOBase() const { return fIOBase; };
		uint32					IRQ() const { return fIRQ; };

private:
static	int32					_DeviceThread(void *data);
		status_t				_WriteToDevice();

static	void					ReadCallbackFunction(void *cookie,
									int32 status, void *data,
									uint32 actualLength);
static	void					WriteCallbackFunction(void *cookie,
									int32 status, void *data,
									uint32 actualLength);
static	void					InterruptCallbackFunction(void *cookie,
									int32 status, void *data,
									uint32 actualLength);

		uint8					ReadReg8(int reg);
		void					WriteReg8(int reg, uint8 value);
		void					OrReg8(int reg, uint8 value);
		void					AndReg8(int reg, uint8 value);
		void					MaskReg8(int reg, uint8 value);

		const struct serial_support_descriptor	*fSupportDescriptor;
		struct serial_config_descriptor		*fDevice;		// USB device handle
		const char *			fDescription;	// informational description
		bool					fDeviceOpen;
		bool					fDeviceRemoved;

		bus_type				fBus;
		uint32					fIOBase;
		uint32					fIRQ;
		const SerialDevice *	fMaster;

		/* line coding */
		//usb_serial_line_coding	fLineCoding;

		/* deferred interrupt */
		uint8					fCachedIER;	// last value written to IER
		uint8					fCachedIIR;	// cached IRQ condition
		int32					fPendingDPC; // some IRQ still

		/* data buffers */
		char					fReadBuffer[DEF_BUFFER_SIZE];
		int32					fReadBufferAvail;
		uint32					fReadBufferIn;
		uint32					fReadBufferOut;
		sem_id					fReadBufferSem;
		char					fWriteBuffer[DEF_BUFFER_SIZE];
		int32					fWriteBufferAvail;
		uint32					fWriteBufferIn;
		uint32					fWriteBufferOut;
		sem_id					fWriteBufferSem;

		/* variables used in callback functionality */
		size_t					fActualLengthRead;
		uint32					fStatusRead;
		size_t					fActualLengthWrite;
		uint32					fStatusWrite;
		size_t					fActualLengthInterrupt;
		uint32					fStatusInterrupt;

		/* semaphores used in callbacks */
		sem_id					fDoneRead;
		sem_id					fDoneWrite;

		uint16					fControlOut;
		bool					fInputStopped;

		struct tty *			fMasterTTY;
		struct tty *			fSlaveTTY;
		struct tty_cookie *		fSystemTTYCookie;
		struct tty_cookie *		fDeviceTTYCookie;
		struct termios			fTTYConfig;

		/* device thread management */
		thread_id				fDeviceThread;
		bool					fStopDeviceThread;
};

#endif // _SERIAL_DEVICE_H_