ref: refs/heads/master

[core]

	repositoryformatversion = 0

	filemode = true

Unnamed repository; edit this file to name it for gitweb.

#!/bin/sh

#

# An example hook script to check the commit log message taken by

# applypatch from an e-mail message.

#

# The hook should exit with non-zero status after issuing an

# appropriate message if it wants to stop the commit.  The hook is

# allowed to edit the commit message file.

#

# To enable this hook, make this file executable.

. git-sh-setup

test -x "$GIT_DIR/hooks/commit-msg" &&

	exec "$GIT_DIR/hooks/commit-msg" ${1+"$@"}

:

#!/bin/sh

#

# An example hook script to check the commit log message.

# Called by git-commit with one argument, the name of the file

# that has the commit message.  The hook should exit with non-zero

# status after issuing an appropriate message if it wants to stop the

# commit.  The hook is allowed to edit the commit message file.

#

# To enable this hook, make this file executable.

# This example catches duplicate Signed-off-by lines.

test "" = "$(grep '^Signed-off-by: ' "$1" |

	 sort | uniq -c | sed -e '/^[ 	]*1 /d')"

#!/bin/sh

#

# An example hook script that is called after a successful

# commit is made.

#

# To enable this hook, make this file executable.

: Nothing

#!/bin/sh

#

# An example hook script to prepare a packed repository for use over

# dumb transports.

#

# To enable this hook, make this file executable by "chmod +x post-update".

exec git-update-server-info

#!/bin/sh

#

# An example hook script to verify what is about to be committed

# by applypatch from an e-mail message.

#

# The hook should exit with non-zero status after issuing an

# appropriate message if it wants to stop the commit.

#

# To enable this hook, make this file executable.

. git-sh-setup

test -x "$GIT_DIR/hooks/pre-commit" &&

	exec "$GIT_DIR/hooks/pre-commit" ${1+"$@"}

:

#!/bin/sh

#

# An example hook script to verify what is about to be committed.

# Called by git-commit with no arguments.  The hook should

# exit with non-zero status after issuing an appropriate message if

# it wants to stop the commit.

#

# To enable this hook, make this file executable.

# This is slightly modified from Andrew Morton's Perfect Patch.

# Lines you introduce should not have trailing whitespace.

# Also check for an indentation that has SP before a TAB.

if git-rev-parse --verify HEAD 2>/dev/null

then

	git-diff-index -p -M --cached HEAD

else

	# NEEDSWORK: we should produce a diff with an empty tree here

	# if we want to do the same verification for the initial import.

	:

fi |

perl -e '

    my $found_bad = 0;

    my $filename;

    my $reported_filename = "";

    my $lineno;

    sub bad_line {

	my ($why, $line) = @_;

	if (!$found_bad) {

	    print STDERR "*\n";

	    print STDERR "* You have some suspicious patch lines:\n";

	    print STDERR "*\n";

	    $found_bad = 1;

	}

	if ($reported_filename ne $filename) {

	    print STDERR "* In $filename\n";

	    $reported_filename = $filename;

	}

	print STDERR "* $why (line $lineno)\n";

	print STDERR "$filename:$lineno:$line\n";

    }

    while (<>) {

	if (m|^diff --git a/(.*) b/\1$|) {

	    $filename = $1;

	    next;

	}

	if (/^@@ -\S+ \+(\d+)/) {

	    $lineno = $1 - 1;

	    next;

	}

	if (/^ /) {

	    $lineno++;

	    next;

	}

	if (s/^\+//) {

	    $lineno++;

	    chomp;

	    if (/\s$/) {

		bad_line("trailing whitespace", $_);

	    }

	    if (/^\s* 	/) {

		bad_line("indent SP followed by a TAB", $_);

	    }

	    if (/^(?:[<>=]){7}/) {

		bad_line("unresolved merge conflict", $_);

	    }

	}

    }

    exit($found_bad);

'

#!/bin/sh

#

# Copyright (c) 2006 Junio C Hamano

#

publish=next

basebranch="$1"

if test "$#" = 2

then

	topic="refs/heads/$2"

else

	topic=`git symbolic-ref HEAD`

fi

case "$basebranch,$topic" in

master,refs/heads/??/*)

	;;

*)

	exit 0 ;# we do not interrupt others.

	;;

esac

# Now we are dealing with a topic branch being rebased

# on top of master.  Is it OK to rebase it?

# Is topic fully merged to master?

not_in_master=`git-rev-list --pretty=oneline ^master "$topic"`

if test -z "$not_in_master"

then

	echo >&2 "$topic is fully merged to master; better remove it."

	exit 1 ;# we could allow it, but there is no point.

fi

# Is topic ever merged to next?  If so you should not be rebasing it.

only_next_1=`git-rev-list ^master "^$topic" ${publish} | sort`

only_next_2=`git-rev-list ^master           ${publish} | sort`

if test "$only_next_1" = "$only_next_2"

then

	not_in_topic=`git-rev-list "^$topic" master`

	if test -z "$not_in_topic"

	then

		echo >&2 "$topic is already up-to-date with master"

		exit 1 ;# we could allow it, but there is no point.

	else

		exit 0

	fi

else

	not_in_next=`git-rev-list --pretty=oneline ^${publish} "$topic"`

	perl -e '

		my $topic = $ARGV[0];

		my $msg = "* $topic has commits already merged to public branch:\n";

		my (%not_in_next) = map {

			/^([0-9a-f]+) /;

			($1 => 1);

		} split(/\n/, $ARGV[1]);

		for my $elem (map {

				/^([0-9a-f]+) (.*)$/;

				[$1 => $2];

			} split(/\n/, $ARGV[2])) {

			if (!exists $not_in_next{$elem->[0]}) {

				if ($msg) {

					print STDERR $msg;

					undef $msg;

				}

				print STDERR " $elem->[1]\n";

			}

		}

	' "$topic" "$not_in_next" "$not_in_master"

	exit 1

fi

exit 0

################################################################

This sample hook safeguards topic branches that have been

published from being rewound.

The workflow assumed here is:

 * Once a topic branch forks from "master", "master" is never

   merged into it again (either directly or indirectly).

 * Once a topic branch is fully cooked and merged into "master",

   it is deleted.  If you need to build on top of it to correct

   earlier mistakes, a new topic branch is created by forking at

   the tip of the "master".  This is not strictly necessary, but

   it makes it easier to keep your history simple.

 * Whenever you need to test or publish your changes to topic

   branches, merge them into "next" branch.

The script, being an example, hardcodes the publish branch name

to be "next", but it is trivial to make it configurable via

$GIT_DIR/config mechanism.

With this workflow, you would want to know:

(1) ... if a topic branch has ever been merged to "next".  Young

    topic branches can have stupid mistakes you would rather

    clean up before publishing, and things that have not been

    merged into other branches can be easily rebased without

    affecting other people.  But once it is published, you would

    not want to rewind it.

(2) ... if a topic branch has been fully merged to "master".

    Then you can delete it.  More importantly, you should not

    build on top of it -- other people may already want to

    change things related to the topic as patches against your

    "master", so if you need further changes, it is better to

    fork the topic (perhaps with the same name) afresh from the

    tip of "master".

Let's look at this example:

		   o---o---o---o---o---o---o---o---o---o "next"

		  /       /           /           /

		 /   a---a---b A     /           /

		/   /               /           /

	       /   /   c---c---c---c B         /

	      /   /   /             \         /

	     /   /   /   b---b C     \       /

	    /   /   /   /             \     /

    ---o---o---o---o---o---o---o---o---o---o---o "master"

A, B and C are topic branches.

 * A has one fix since it was merged up to "next".

 * B has finished.  It has been fully merged up to "master" and "next",

   and is ready to be deleted.

 * C has not merged to "next" at all.

We would want to allow C to be rebased, refuse A, and encourage

B to be deleted.

To compute (1):

	git-rev-list ^master ^topic next

	git-rev-list ^master        next

	if these match, topic has not merged in next at all.

To compute (2):

	git-rev-list master..topic

	if this is empty, it is fully merged to "master".

#!/bin/sh

#

# An example hook script to mail out commit update information.

# It also blocks tags that aren't annotated.

# Called by git-receive-pack with arguments: refname sha1-old sha1-new

#

# To enable this hook:

# (1) change the recipient e-mail address

# (2) make this file executable by "chmod +x update".

#

project=$(cat $GIT_DIR/description)

recipients="commit-list@somewhere.com commit-list@somewhereelse.com"

ref_type=$(git cat-file -t "$3")

# Only allow annotated tags in a shared repo

# Remove this code to treat dumb tags the same as everything else

case "$1","$ref_type" in

refs/tags/*,commit)

	echo "*** Un-annotated tags are not allowed in this repo" >&2

	echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate."

	exit 1;;

refs/tags/*,tag)

	echo "### Pushing version '${1##refs/tags/}' to the masses" >&2

	# recipients="release-announce@somwehere.com announce@somewhereelse.com"

	;;

esac

# set this  to 'cat' to get a very detailed listing.

# short only kicks in when an annotated tag is added

short='git shortlog'

# see 'date --help' for info on how to write this

# The default is a human-readable iso8601-like format with minute

# precision ('2006-01-25 15:58 +0100' for example)

date_format="%F %R %z"

(if expr "$2" : '0*$' >/dev/null

then

	# new ref

	case "$1" in

	refs/tags/*)

		# a pushed and annotated tag (usually) means a new version

		tag="${1##refs/tags/}"

		if [ "$ref_type" = tag ]; then

			eval $(git cat-file tag $3 | \

				sed -n '4s/tagger \([^>]*>\)[^0-9]*\([0-9]*\).*/tagger="\1" ts="\2"/p')

			date=$(date --date="1970-01-01 00:00:00 $ts seconds" +"$date_format")

			echo "Tag '$tag' created by $tagger at $date"

			git cat-file tag $3 | sed -n '5,$p'

			echo

		fi

		prev=$(git describe "$3^" | sed 's/-g.*//')

		# the first tag in a repo will yield no $prev

		if [ -z "$prev" ]; then

			echo "Changes since the dawn of time:"

			git rev-list --pretty $3 | $short

		else

			echo "Changes since $prev:"

			git rev-list --pretty $prev..$3 | $short

			echo ---

			git diff $prev..$3 | diffstat -p1

			echo ---

		fi

		;;

	refs/heads/*)

		branch="${1##refs/heads/}"

		echo "New branch '$branch' available with the following commits:"

		git-rev-list --pretty "$3" $(git-rev-parse --not --all)

		;;

	esac

else

	base=$(git-merge-base "$2" "$3")

	case "$base" in

	"$2")

		git diff "$3" "^$base" | diffstat -p1

		echo

		echo "New commits:"

		;;

	*)

		echo "Rebased ref, commits from common ancestor:"

		;;

	esac

	git-rev-list --pretty "$3" "^$base"

fi) |

mail -s "$project: Changes to '${1##refs/heads/}'" $recipients

exit 0

# git-ls-files --others --exclude-from=.git/info/exclude

# Lines that start with '#' are comments.

# For a project mostly in C, the following would be a good set of

# exclude patterns (uncomment them if you want to use them):

# *.[oa]

# *~

xڥ�An� E�������0X��HU/�80(V��Ur��\���7�XKY;��o����%�L)e?�<��1gf$䅙��10�ci�w0�&�S28�dC���^\�x�0-ɳ�Z~��6�n�u�s��C���qD}�E�붺�X���:g;�5��

������X7��> ��]�G�k��G�.�M=
z�R�

x�e�_k�0���|�K���զjZ��������Hۤ��$����m���v8��sIZ�)D�ǻ�K�/llwZW:]�� �1�!��>����pNf��pu��B�̊�q�k�D9�>_[g�����6��u�L��֪���†"E�i`��H�&�!�&����\u�7q*��FrVO ��e�V1q0��V(�[%bB����{.=7`��ϡ��X�/�^?;���g��@;`9{�T�<C..8�$��Q�`e����� l�RĢ�k�-�X��Di�4��D�m#�q+

�M֢��Q	�-�߾��|K��KȊ�k�i`�i���xV�+��M���'v�ٓ��

xڥ�Kj�0D��)z0��jA�d��@ВZ3�d�f&�����G}b+e`�}�B`��R�H��'4�r3".)yv��ةs��&�N+�����dLD�I�Ά�A�qm>�s�pi��!?~�8][�鴽mSl���g7�F�RK)�9t�?"ąK{0t��^�X[��`��8�<�׵���=�`���u�I��qc:�?��d�

xڍα� P��wv ��N������<,)�0�/������ܧ\PhD��ң����X�Gp8�/ۍ��>LgV��̤aB�HѓK�PDV�w\���#�4�����u!%���9 ��Br�>M6�U��S�lMs�BQ�����ﭭ"ɑ3�O$F�

x�e��k�0�����n�V���к�Ƅ��MD��j����~0��/�-���p�=�����R�&Owa�@^��Ӻ���pm�L(�(��t�06c�����:

	`s!!�Bfe�s�k��j�}���:4�=��mms��4�UKa[�#B�%Bz(��ȶ��>,W>�!N-��H�7H��j��*&Ɗ���N������=����ڏ�n�X~,�߾|\-��[s�>�CΞ+U)�Ő�?	��_��x�����Y�X��m�#+��(��6t!��(�m�9nE�=�f-���0��+<��[T\BV\X�L{Mk/7dz��Xٴ(nj%-<��?[��

xڥ�K

�0@]��J�f�D�x
�L&S+�M	=��+�{o�x\�����~ת`=ZOI�M��]N(dØ�<J��kQUY�H�i���N3�G�e�!"�O�8ˁ=�T*���¥�p�/�^wSY��i-s�e9�1�u0{m�V�m�GB]�LM�'Zo2��z�N�

x��K

�0Ea��*��Ai���
]A764�_���{���78&��8�v�O����{����D���uk��[I��qs�v�]��D�h3ъ�5��
��=B�ھ0�R'!����W���,

3bfaeb835bec3d26d8ae0fd9d6b9b1dc15eafa7a

3bfaeb835bec3d26d8ae0fd9d6b9b1dc15eafa7a

URL: http://www.erwinrol.com/git/dmx_usb_module

Pull: refs/heads/master:refs/heads/origin

08 Aug 2006 Erwin Rol <erwin@erwinrol.com>

	* Updated for kernels newer than 2.6.16

16 Jan 2006 Erwin Rol <erwin@erwinrol.com>

	* Updated for kernels newer than 2.6.13

15 Sep 2004 Erwin Rol <erwin@erwinrol.com>

	* Added a check to see if the transmit 

	  buffer is empty before doing the break.

#

# $Id: Makefile 38 2004-09-11 11:15:09Z erwin $

#

ifneq ($(KERNELRELEASE),)

obj-m := dmx_usb.o

else

KDIR	:= /lib/modules/$(shell uname -r)/build

PWD	:= $(shell pwd)

default:

	$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules

	gcc -O2 -pipe dmx_usb_test.c -o dmx_usb_test

endif

clean:

	rm -f *.o *.ko

	rm -f dmx_usb_test

	rm -f dmx_usb.mod.c

	rm -f .dmx_usb.*

	rm -rf .tmp_versions

drew:

	gcc dmx_usb.c -o dmx_usb.o -I/usr/src/linux-source-2.6.15/include

The DMX USB driver is a Linux 2.6 kernel driver for the Enttec

DMX USB dongle ( http://www.enttec.com/dmxusb.php )

Building the driver

Before the driver can be build, the kernel sourcecode needs to be 

installed. To build the driver just call make, this should build a

dmx_usb.ko (the kernel module) and a dmx_usb_test(a small test

program).

Loading the right driver.

A "small" problem to solve was to make the kernel clear that it should 

use my driver for the dongle and not the standard usbserial driver. 

Since I don't have any other USBserial devices with the samechip type I 

just removed the ftdi_sio.ko module, and changed the /etc/hotplug/usb.distmap 

to point to my module. To support both the ftdi_sio.o module and the 

dmx_usb.o module the ftdi_sio.o module should be patched and the Product ID 

for the FT232BM should be removed from it, this will mean all other 

serial-usb devices are still supported just not the one with FT232BM chips, 

since it isn't possible to differentiate DMX-USB and normal-serial versions.

cdef extern from "fcntl.h":

    int open(char *pathname, int flags)

    int O_WRONLY

cdef extern from "unistd.h":

    int write(int fd, void *buf, int count)

cdef extern from "string.h":

    char *strncpy(char *dest, char *src, int n)

cdef extern from "Python.h":

    char* PyString_AsString(object string)

cdef class Dmx:

    cdef int fd

    def __new__(self, port="/dev/dmx0"):

        self.fd = open(port, O_WRONLY)

        if self.fd < 0:

            raise OSError("open failed")

    def write(self, buf):

        cdef char *cbuf

        cbuf = PyString_AsString(buf)

        if cbuf == NULL:

            raise

        res = write(self.fd, cbuf, 513)

        if res < 0:

            raise OSError("write failed")

/*

 * DMX USB driver

 *

 * Copyright (C) 2004,2006 Erwin Rol (erwin@erwinrol.com)

 *

 * This driver is based on the usb-skeleton driver;

 *

 * Copyright (C) 2001-2003 Greg Kroah-Hartman (greg@kroah.com)

 *

 *	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, version 2.

 *

 * $Id: dmx_usb.c 41 2004-09-14 23:35:25Z erwin $ 

 */

#include <linux/kernel.h>

#include <linux/errno.h>

#include <linux/init.h>

#include <linux/slab.h>

#include <linux/module.h>

#include <linux/smp_lock.h>

#include <linux/completion.h>

#include <asm/uaccess.h>

#include <linux/usb.h>

#include <linux/version.h>

#include "dmx_usb.h"

#ifdef CONFIG_USB_DEBUG

	static int debug = 1;

#else

	static int debug;

#endif

/* Use our own dbg macro */

#undef dbg

#define dbg(format, arg...) do { if (debug) printk(KERN_DEBUG __FILE__ ": " format "\n" , ## arg); } while (0)

/* Version Information */

#define DRIVER_VERSION "v0.1.20060816"

#define DRIVER_AUTHOR "Erwin Rol, erwin@erwinrol.com"

#define DRIVER_DESC "DMX USB Driver"

/* Module parameters */

#if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16) )

MODULE_PARM(debug, "i");

MODULE_PARM_DESC(debug, "Debug enabled or not");

#else

module_param(debug, bool, S_IRUGO | S_IWUSR);

MODULE_PARM_DESC(debug, "Debug enabled or not");

#endif

static struct usb_device_id dmx_usb_table [] = {

	{ USB_DEVICE_VER(FTDI_VID, FTDI_8U232AM_PID, 0x400, 0xffff) },

	{ USB_DEVICE_VER(FTDI_VID, FTDI_8U232AM_ALT_PID, 0x400, 0xffff) },

	{ }                                             /* Terminating entry */

};

MODULE_DEVICE_TABLE (usb, dmx_usb_table);

/* Get a minor range for your devices from the usb maintainer */

#define DMX_USB_MINOR_BASE	192

/* Structure to hold all of our device specific stuff */

struct dmx_usb_device {

	struct usb_device *	udev;			/* save off the usb device pointer */

	struct usb_interface *	interface;		/* the interface for this device */

	unsigned char		minor;			/* the starting minor number for this device */

	unsigned char		num_ports;		/* the number of ports this device has */

	char			num_interrupt_in;	/* number of interrupt in endpoints we have */

	char			num_bulk_in;		/* number of bulk in endpoints we have */

	char			num_bulk_out;		/* number of bulk out endpoints we have */

	unsigned char *		bulk_in_buffer;		/* the buffer to receive data */

	size_t			bulk_in_size;		/* the size of the receive buffer */

	__u8			bulk_in_endpointAddr;	/* the address of the bulk in endpoint */

	unsigned char *		bulk_out_buffer;	/* the buffer to send data */

	size_t			bulk_out_size;		/* the size of the send buffer */

	struct urb *		write_urb;		/* the urb used to send data */

	__u8			bulk_out_endpointAddr;	/* the address of the bulk out endpoint */

	atomic_t		write_busy;		/* true iff write urb is busy */

	struct completion	write_finished;		/* wait for the write to finish */

	int			open;			/* if the port is open or not */

	int			present;		/* if the device is not disconnected */

	struct semaphore	sem;			/* locks this structure */

};

/* prevent races between open() and disconnect() */

static DECLARE_MUTEX (disconnect_sem);

/* local function prototypes */

//static ssize_t dmx_usb_read	(struct file *file, char *buffer, size_t count, loff_t *ppos);

static ssize_t dmx_usb_write	(struct file *file, const char *buffer, size_t count, loff_t *ppos);

static int dmx_usb_ioctl	(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);

static int dmx_usb_open		(struct inode *inode, struct file *file);

static int dmx_usb_release	(struct inode *inode, struct file *file);

static int dmx_usb_probe	(struct usb_interface *interface, const struct usb_device_id *id);

static void dmx_usb_disconnect	(struct usb_interface *interface);

static void dmx_usb_write_bulk_callback	(struct urb *urb, struct pt_regs *regs);

static struct file_operations dmx_usb_fops = {

	/*

	 * The owner field is part of the module-locking

	 * mechanism. The idea is that the kernel knows

	 * which module to increment the use-counter of

	 * BEFORE it calls the device's open() function.

	 * This also means that the kernel can decrement