1009.fip.patch

sm86xx内核源包括补丁（ GPL ）的

+
+/* Default brightness level */
+#define BRIGHTNESS		0x7
+
+/* The number of key polling per second */
+#define POLL_PER_SECOND		10
+
+#ifdef __KERNEL__
+/* The major device number and name */
+#define FIP_DEV_MAJOR		0
+
+#define DRIVER_VERSION         "1.14"
+
+MODULE_DESCRIPTION("TANGOX front panel fip driver\n");
+MODULE_AUTHOR("TANGOX standalone team");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRIVER_VERSION);
+
+/* Wait queue, may be used if block mode is on */
+DECLARE_WAIT_QUEUE_HEAD(fip_wq);
+
+MODULE_PARM(major_num, "i");
+MODULE_PARM(buffer_size, "i");
+MODULE_PARM(wait_period, "i");
+MODULE_PARM(brightness, "i");
+MODULE_PARM(poll_per_sec, "i");
+
+/* Some prototypes */
+static int fip_open(struct inode *, struct file *);
+static int fip_release(struct inode *, struct file *);
+static int fip_read(struct file *, char *, size_t, loff_t *);
+static int fip_write(struct file *, const char *, size_t, loff_t *);
+static int fip_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
+static unsigned int fip_poll(struct file *, struct poll_table_struct *);
+static int buffer_size = BUF_SIZE;
+static int wait_period = WAIT_PERIOD;
+static unsigned int poll_per_sec = POLL_PER_SECOND;
+static int fip_irq = LOG2_CPU_FRONTPANEL_INT + IRQ_CONTROLLER_IRQ_BASE;
+static irqreturn_t fip_isr(int irq, void *dev_id, struct pt_regs *regs);
+static void fip_poll_key(unsigned long devid);
+
+static struct timer_list fip_timer;
+#if 0
+static struct tq_struct immediate;
+#endif
+
+static void fip_write_text(const int position, const char *text, const int flags);
+static int fip_show_hms(int hour, int minute, int second);
+static void fip_display_symbol(const int symbol, const int on);
+static int fip_display_character(const int position, const char character);
+static void fip_display_raw(const int byte, const int bit, const int on); 
+static int is_fip_busy(void);
+static int is_fip_busy_nowait(void);
+static void fip_clear(void);
+
+#else /* For Bootloader */
+
+void fip_write_text(const int position, const char *text, const int flags);
+void fip_display_symbol(const int symbol, const int on);
+int fip_display_character(const int position, const char character);
+void fip_display_raw(const int byte, const int bit, const int on); 
+int is_fip_busy(void);
+void fip_clear(void);
+int fip_init(void);
+int fip_exit(void);
+
+/* Some external functions from bootloader core */
+void em86xx_usleep(int usec);
+int uart_printf(const char *fmt, ...);
+int strlen(const char *str);
+
+#endif /* __KERNEL__ */
+
+#define FIP_DEV_NAME		"fip"
+
+static void fip_write_reg(unsigned int offset, unsigned int val);
+static unsigned int fip_read_reg(unsigned int offset);
+
+#ifdef __KERNEL__ 
+#define CMDQ_SIZE	256
+
+/* Private data structure */
+struct cmd_request {
+	unsigned int cmd;
+	unsigned int data;
+};
+
+struct fip_private {
+	unsigned long *buffer;		/* Circular buffer */
+	unsigned p_idx;			/* Index of producer */
+	unsigned c_idx; 		/* Index of consumer */
+	unsigned ref_cnt;		/* Reference count */
+	spinlock_t lock;		/* Spin lock */
+	unsigned char b_mode;		/* Blocking mode or not */
+	unsigned long last_jiffies;	/* Timestamp for last reception */
+#ifdef ENABLE_WRITE_INTR
+	struct cmd_request cmds[CMDQ_SIZE];
+	unsigned cmd_pidx;
+	unsigned cmd_cidx;
+	unsigned cmdq_empty;
+#endif
+};
+
+static struct file_operations fip_fops = {
+	open: fip_open,
+	read: fip_read,
+	ioctl: fip_ioctl,
+	poll: fip_poll,
+	write: fip_write,
+	release: fip_release,
+	owner: THIS_MODULE,
+};
+
+static void fip_push_key(struct fip_private *priv, unsigned long key);
+#ifdef ENABLE_WRITE_INTR
+static void fip_issue_command(struct fip_private *priv);
+static void fip_queue_command(unsigned int cmd, unsigned int data);
+#endif
+
+/* Global data */
+static struct fip_private fip_priv;
+static int major_num = FIP_DEV_MAJOR;
+#endif /* __KERNEL__ */
+
+static char *fip_devname = FIP_DEV_NAME;
+static int brightness = BRIGHTNESS;
+static unsigned long fip_base = (unsigned long)FIP_BASE;
+static char fipram[MAX_FIP_RAM] = {0};
+
+#ifdef __KERNEL__
+
+static irqreturn_t fip_isr(int irq, void *dev_id, struct pt_regs *regs)
+{
+	struct fip_private *priv = (struct fip_private *)dev_id;
+	unsigned long stat;
+	unsigned long key;
+
+	if (irq == fip_irq) {
+		//gbus_write_uint32(pGBus, REG_BASE_CPU + CPU_edge_rawstat,  IRQMASKOF(irq));
+		stat = (fip_read_reg(FIP_INT) & 0x3);
+		fip_write_reg(FIP_INT, stat); /* Clear the interrupt */
+
+		if (!is_fip_busy_nowait()) {
+			if (stat & 0x2) {
+				key = fip_read_reg(FIP_KEY_DATA1);
+				fip_push_key(priv, key);
+			}
+#ifdef ENABLE_WRITE_INTR
+			fip_issue_command(priv);
+#endif
+		}
+		return IRQ_HANDLED;
+	} else {
+		printk("Unknown IRQ %d\n", irq);
+		return IRQ_NONE;
+	}
+
+}
+
+static void fip_poll_key(unsigned long devid)
+{
+	struct fip_private *priv = (struct fip_private *)devid;
+
+	/* Sending command, and later ISR will pick up the interrupt and read
+           the key */
+	if (!is_fip_busy_nowait()) {
+		fip_write_reg(FIP_COMMAND, FIP_CMD_DATA_SET_RW_MODE_READ_KEYS);
+#ifdef ENABLE_WRITE_INTR
+		if (priv->cmdq_empty != 0) {
+			fip_issue_command(priv);
+		}
+#endif
+	}
+
+	if (priv->ref_cnt != 0) {
+		mod_timer(&fip_timer, jiffies + (HZ / poll_per_sec));
+#if 0
+		queue_task(&immediate, &tq_immediate);
+		mark_bh(IMMEDIATE_BH);
+#endif
+	}
+}
+
+/* Produce data */
+static void fip_push_key(struct fip_private *priv, unsigned long key)
+{
+	unsigned pidx;
+	static unsigned long oldkey = 0;
+
+	spin_lock(&priv->lock);
+
+	if ((key == 0) || (key == 0xffffffff)) {
+		oldkey = 0;
+		goto out;
+	} else if (time_after(priv->last_jiffies + wait_period, jiffies) 
+			&& (key == oldkey))
+		goto out;
+	else
+		priv->last_jiffies = jiffies;
+	
+	printk(KERN_DEBUG "%s: got data 0x%08lx\n", fip_devname, key);
+
+	pidx = priv->p_idx;	/* Save the old index before proceeding */
+
+	/* Save it to buffer */
+	if (((priv->p_idx + 1) % buffer_size) == priv->c_idx) {
+		/* Adjust consumer index since buffer is full */
+		/* Keep the latest one and drop the oldest one */
+		priv->c_idx = (priv->c_idx + 1) % buffer_size;
+
+		printk(KERN_WARNING "%s: buffer full\n", fip_devname);
+	}
+
+	priv->buffer[priv->p_idx] = oldkey = key;
+	priv->p_idx = (priv->p_idx + 1) % buffer_size;
+
+	/* Buffer was empty and block mode is on, wake up the reader */
+	if ((priv->b_mode != 0) && (priv->c_idx == pidx))
+		wake_up_interruptible(&fip_wq);
+
+out:
+	spin_unlock(&priv->lock);
+}
+
+/* Reading from driver's buffer, note that it can return read size
+   less than specified */
+static int fip_consume(void *dev_id, unsigned long *buf, int count)
+{
+	struct fip_private *priv = (struct fip_private *)dev_id;
+	int cnt;
+	unsigned long flags;
+
+	/* If block mode is on, check the emptiness of buffer */
+	if (priv->b_mode != 0) {
+		/* Sleep when buffer is empty */
+		wait_event_interruptible(fip_wq, priv->c_idx != priv->p_idx);
+	}
+
+	spin_lock_irqsave(&priv->lock, flags);
+
+	/* Get the data out and adjust consumer index */
+	for (cnt = 0; (priv->c_idx != priv->p_idx) && (cnt < count); cnt++) {
+		*buf = priv->buffer[priv->c_idx];
+		priv->c_idx = (priv->c_idx + 1) % buffer_size;
+		buf++;
+	}
+
+	spin_unlock_irqrestore(&priv->lock, flags);
+
+	return(cnt);
+}
+
+/* Poll function */
+static unsigned int fip_poll(struct file *fptr, struct poll_table_struct *ptable){
+	struct fip_private *priv = (struct fip_private *)fptr->private_data;
+	unsigned int mask = 0;
+
+	poll_wait(fptr, &fip_wq, ptable);
+	if (priv->c_idx != priv->p_idx)
+		mask |= (POLLIN | POLLRDNORM);
+	return(mask);
+}
+
+#ifdef ENABLE_WRITE_INTR
+static void fip_issue_command(struct fip_private *priv)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&priv->lock, flags);
+
+	if (priv->cmd_pidx == priv->cmd_cidx) {
+		priv->cmdq_empty = 1;
+		goto out;
+	} else if (!is_fip_busy_nowait()) {
+		priv->cmdq_empty = 0;
+		fip_wait_ready();
+		fip_write_reg(FIP_DISPLAY_DATA, priv->cmds[priv->cmd_cidx].data);
+		fip_wait_ready();
+		fip_write_reg(FIP_COMMAND, priv->cmds[priv->cmd_cidx].cmd);
+		fip_wait_ready();
+		priv->cmd_cidx = ((priv->cmd_cidx + 1) % CMDQ_SIZE);
+		if (priv->cmd_pidx == priv->cmd_cidx) 
+			priv->cmdq_empty = 1;
+	}
+out:
+	spin_unlock_irqrestore(&priv->lock, flags);
+}
+#endif
+
+static int fip_open(struct inode *inode_ptr, struct file *fptr)
+{
+	/* This device is exclusive, that is, only one process can use it */
+	if (fip_priv.ref_cnt != 0) {
+		printk(KERN_WARNING "%s: exclusive access only\n", fip_devname);
+		return(-EIO);
+	} 
+
+	/* Set the block mode and increase reference count */
+	fip_priv.ref_cnt++;
+	fip_priv.b_mode = ((fptr->f_flags & O_NONBLOCK) ? 0 : 1);
+	fip_priv.last_jiffies = jiffies;
+
+	/* Flush the buffer */
+	fip_priv.p_idx = fip_priv.c_idx = 0;
+
+	fptr->f_op = &fip_fops;
+	fptr->private_data = (void *)&fip_priv;
+
+	fip_timer.function = fip_poll_key;
+	fip_timer.data = (unsigned long)&fip_priv;
+	fip_timer.expires = jiffies + (HZ / poll_per_sec);
+	add_timer(&fip_timer);
+
+#if 0
+	immediate.sync = 0;
+	immediate.data = (void *)&fip_priv;
+	immediate.routine = fip_poll_key;
+	queue_task(&immediate, &tq_immediate);
+	mark_bh(IMMEDIATE_BH);
+#endif
+
+	fip_clear();
+	return(0);
+}
+
+static int fip_release(struct inode *inode_ptr, struct file *fptr) 
+{
+	unsigned long start = 0;
+
+	/* Adjust reference count */
+	fip_priv.ref_cnt--;
+
+	/* Wait for timer expiration */
+	for (start = jiffies; time_after(start + 2 * (HZ / poll_per_sec), jiffies););
+	del_timer_sync(&fip_timer);
+	return(0);
+}
+
+static int fip_read(struct file *fptr, char *bufptr, size_t size, loff_t *fp)
+{
+	unsigned long buf[buffer_size];
+	int count = 0;
+
+	/* Check the alignment */
+	if (size % sizeof(unsigned long)) {
+		printk(KERN_WARNING "%s: read size not aligned to %d\n",
+			fip_devname, sizeof(unsigned long));
+		return(-EIO);
+	}
+
+	count = fip_consume(fptr->private_data, &buf[0], 
+			size / sizeof(unsigned long)) * sizeof(unsigned long);
+
+	/* Get the data to user */
+	if (count && copy_to_user(bufptr, (char *)&buf[0], count)) 
+		return(-EFAULT);
+
+	return(count);
+}
+
+static int fip_write(struct file *fptr, const char *bufptr, size_t size, loff_t *fp)
+{
+	fip_wait_ready();
+	fip_write_text(0, bufptr, FIP_CENTER); 
+	fip_wait_ready();
+	return(size);
+}
+
+static int fip_ioctl(struct inode *inode, struct file *fptr, unsigned int cmd, unsigned long arg)
+{
+	int on = 0;
+	int symbol;
+	int i, j, k;
+
+	switch(cmd) {
+		case FIP_IOCSHOWSYMBOL:
+			on = ((arg & 0x80000000)) == 0 ? 0 : 1;
+			symbol = (int)(arg & 0xff);
+			fip_display_symbol(symbol, on);
+			break;
+		case FIP_IOCSHOWHMS:
+			k = (int)(arg & 0xff);
+			j = (int)((arg >> 8) & 0xff);
+			i = (int)((arg >> 16) & 0xff);
+			fip_show_hms(i, j, k);
+			break;
+		case FIP_IOCDISPCHAR:
+			k = (int)(arg & 0xff);
+			j = (int)((arg >> 8) & 0xff);
+			fip_display_character(j, k);
+			break;
+		case FIP_IOCDISPRAW:
+			on = ((arg & 0x80000000)) == 0 ? 0 : 1;
+			k = (int)(arg & 0xff);
+			j = (int)((arg >> 8) & 0xff);
+			fip_display_raw(j, k, on);
+			break;
+		case FIP_IOCDISPTEXT:
+			printk("%s: ioctl FIP_IOCDISPTEXT not implemented.\n", fip_devname);
+			return(-EIO);
+		case FIP_IOCCLEAR:
+			fip_clear();
+			break;
+		case FIP_IOCGETFPTYPE:
+			{
+				unsigned long *ptr = (unsigned long *)arg;
+				unsigned long type = 0;
+#if defined(CONFIG_TANGOX_FIP_REF1)
+				type = 1;
+#elif defined(CONFIG_TANGOX_FIP_REF2)
+				type = 2;
+#else
+				return(-EIO);