2017-11-03 18:28:30 +08:00
|
|
|
// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
|
|
|
|
*
|
2005-08-29 23:01:16 +08:00
|
|
|
* Main part
|
|
|
|
*
|
2005-04-17 06:20:36 +08:00
|
|
|
* Copyright (C) 2005 by Thomas Winischhofer, Vienna, Austria
|
|
|
|
*
|
|
|
|
* If distributed as part of the Linux kernel, this code is licensed under the
|
|
|
|
* terms of the GPL v2.
|
|
|
|
*
|
|
|
|
* Otherwise, the following license terms apply:
|
|
|
|
*
|
|
|
|
* * Redistribution and use in source and binary forms, with or without
|
|
|
|
* * modification, are permitted provided that the following conditions
|
|
|
|
* * are met:
|
|
|
|
* * 1) Redistributions of source code must retain the above copyright
|
|
|
|
* * notice, this list of conditions and the following disclaimer.
|
|
|
|
* * 2) Redistributions in binary form must reproduce the above copyright
|
|
|
|
* * notice, this list of conditions and the following disclaimer in the
|
|
|
|
* * documentation and/or other materials provided with the distribution.
|
|
|
|
* * 3) The name of the author may not be used to endorse or promote products
|
|
|
|
* * derived from this software without specific psisusbr written permission.
|
|
|
|
* *
|
|
|
|
* * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESSED OR
|
|
|
|
* * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
|
* * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
* * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
* * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
* * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
2007-08-10 21:34:24 +08:00
|
|
|
* Author: Thomas Winischhofer <thomas@winischhofer.net>
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
#include <linux/mutex.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/kref.h>
|
|
|
|
#include <linux/usb.h>
|
2005-08-29 23:01:16 +08:00
|
|
|
#include <linux/vmalloc.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#include "sisusb.h"
|
2005-08-29 23:01:16 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define SISUSB_DONTSYNC
|
|
|
|
|
|
|
|
/* Forward declarations / clean-up routines */
|
|
|
|
|
|
|
|
static struct usb_driver sisusb_driver;
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static void sisusb_free_buffers(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NUMOBUFS; i++) {
|
2016-01-16 01:41:32 +08:00
|
|
|
kfree(sisusb->obuf[i]);
|
|
|
|
sisusb->obuf[i] = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2016-01-16 01:41:32 +08:00
|
|
|
kfree(sisusb->ibuf);
|
|
|
|
sisusb->ibuf = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static void sisusb_free_urbs(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NUMOBUFS; i++) {
|
|
|
|
usb_free_urb(sisusb->sisurbout[i]);
|
|
|
|
sisusb->sisurbout[i] = NULL;
|
|
|
|
}
|
|
|
|
usb_free_urb(sisusb->sisurbin);
|
|
|
|
sisusb->sisurbin = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Level 0: USB transport layer */
|
|
|
|
|
|
|
|
/* 1. out-bulks */
|
|
|
|
|
|
|
|
/* out-urb management */
|
|
|
|
|
|
|
|
/* Return 1 if all free, 0 otherwise */
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_all_free(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < sisusb->numobufs; i++) {
|
|
|
|
|
|
|
|
if (sisusb->urbstatus[i] & SU_URB_BUSY)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Kill all busy URBs */
|
2016-01-16 01:41:29 +08:00
|
|
|
static void sisusb_kill_all_busy(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (sisusb_all_free(sisusb))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < sisusb->numobufs; i++) {
|
|
|
|
|
|
|
|
if (sisusb->urbstatus[i] & SU_URB_BUSY)
|
|
|
|
usb_kill_urb(sisusb->sisurbout[i]);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return 1 if ok, 0 if error (not all complete within timeout) */
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_wait_all_out_complete(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int timeout = 5 * HZ, i = 1;
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
wait_event_timeout(sisusb->wait_q, (i = sisusb_all_free(sisusb)),
|
|
|
|
timeout);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_outurb_available(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < sisusb->numobufs; i++) {
|
|
|
|
|
|
|
|
if ((sisusb->urbstatus[i] & (SU_URB_BUSY|SU_URB_ALLOC)) == 0)
|
|
|
|
return i;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_get_free_outbuf(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i, timeout = 5 * HZ;
|
|
|
|
|
|
|
|
wait_event_timeout(sisusb->wait_q,
|
2016-01-16 01:41:29 +08:00
|
|
|
((i = sisusb_outurb_available(sisusb)) >= 0), timeout);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_alloc_outbuf(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
i = sisusb_outurb_available(sisusb);
|
|
|
|
|
|
|
|
if (i >= 0)
|
|
|
|
sisusb->urbstatus[i] |= SU_URB_ALLOC;
|
|
|
|
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static void sisusb_free_outbuf(struct sisusb_usb_data *sisusb, int index)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
if ((index >= 0) && (index < sisusb->numobufs))
|
|
|
|
sisusb->urbstatus[index] &= ~SU_URB_ALLOC;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* completion callback */
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static void sisusb_bulk_completeout(struct urb *urb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_urb_context *context = urb->context;
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sisusb = context->sisusb;
|
|
|
|
|
|
|
|
if (!sisusb || !sisusb->sisusb_dev || !sisusb->present)
|
|
|
|
return;
|
|
|
|
|
|
|
|
#ifndef SISUSB_DONTSYNC
|
|
|
|
if (context->actual_length)
|
|
|
|
*(context->actual_length) += urb->actual_length;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
sisusb->urbstatus[context->urbindex] &= ~SU_URB_BUSY;
|
|
|
|
wake_up(&sisusb->wait_q);
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_bulkout_msg(struct sisusb_usb_data *sisusb, int index,
|
|
|
|
unsigned int pipe, void *data, int len, int *actual_length,
|
|
|
|
int timeout, unsigned int tflags)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct urb *urb = sisusb->sisurbout[index];
|
|
|
|
int retval, byteswritten = 0;
|
|
|
|
|
|
|
|
/* Set up URB */
|
|
|
|
urb->transfer_flags = 0;
|
|
|
|
|
|
|
|
usb_fill_bulk_urb(urb, sisusb->sisusb_dev, pipe, data, len,
|
2016-01-16 01:41:29 +08:00
|
|
|
sisusb_bulk_completeout,
|
|
|
|
&sisusb->urbout_context[index]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
[PATCH] USB: URB_ASYNC_UNLINK flag removed from the kernel
29 July 2005, Cambridge, MA:
This afternoon Alan Stern submitted a patch to remove the URB_ASYNC_UNLINK
flag from the Linux kernel. Mr. Stern explained, "This flag is a relic
from an earlier, less-well-designed system. For over a year it hasn't
been used for anything other than printing warning messages."
An anonymous spokesman for the Linux kernel development community
commented, "This is exactly the sort of thing we see happening all the
time. As the kernel evolves, support for old techniques and old code can
be jettisoned and replaced by newer, better approaches. Proprietary
operating systems do not have the freedom or flexibility to change so
quickly."
Mr. Stern, a staff member at Harvard University's Rowland Institute who
works on Linux only as a hobby, noted that the patch (labelled as548) did
not update two files, keyspan.c and option.c, in the USB drivers' "serial"
subdirectory. "Those files need more extensive changes," he remarked.
"They examine the status field of several URBs at times when they're not
supposed to. That will need to be fixed before the URB_ASYNC_UNLINK flag
is removed."
Greg Kroah-Hartman, the kernel maintainer responsible for overseeing all
of Linux's USB drivers, did not respond to our inquiries or return our
calls. His only comment was "Applied, thanks."
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-07-30 04:11:07 +08:00
|
|
|
urb->transfer_flags |= tflags;
|
2005-04-17 06:20:36 +08:00
|
|
|
urb->actual_length = 0;
|
|
|
|
|
|
|
|
/* Set up context */
|
|
|
|
sisusb->urbout_context[index].actual_length = (timeout) ?
|
2016-01-16 01:41:28 +08:00
|
|
|
NULL : actual_length;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Declare this urb/buffer in use */
|
|
|
|
sisusb->urbstatus[index] |= SU_URB_BUSY;
|
|
|
|
|
|
|
|
/* Submit URB */
|
2010-02-20 08:40:54 +08:00
|
|
|
retval = usb_submit_urb(urb, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* If OK, and if timeout > 0, wait for completion */
|
|
|
|
if ((retval == 0) && timeout) {
|
|
|
|
wait_event_timeout(sisusb->wait_q,
|
2016-01-16 01:41:28 +08:00
|
|
|
(!(sisusb->urbstatus[index] & SU_URB_BUSY)),
|
|
|
|
timeout);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (sisusb->urbstatus[index] & SU_URB_BUSY) {
|
|
|
|
/* URB timed out... kill it and report error */
|
|
|
|
usb_kill_urb(urb);
|
|
|
|
retval = -ETIMEDOUT;
|
|
|
|
} else {
|
|
|
|
/* Otherwise, report urb status */
|
|
|
|
retval = urb->status;
|
|
|
|
byteswritten = urb->actual_length;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (actual_length)
|
|
|
|
*actual_length = byteswritten;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 2. in-bulks */
|
|
|
|
|
|
|
|
/* completion callback */
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static void sisusb_bulk_completein(struct urb *urb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb = urb->context;
|
|
|
|
|
|
|
|
if (!sisusb || !sisusb->sisusb_dev || !sisusb->present)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sisusb->completein = 1;
|
|
|
|
wake_up(&sisusb->wait_q);
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_bulkin_msg(struct sisusb_usb_data *sisusb,
|
|
|
|
unsigned int pipe, void *data, int len,
|
|
|
|
int *actual_length, int timeout, unsigned int tflags)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct urb *urb = sisusb->sisurbin;
|
|
|
|
int retval, readbytes = 0;
|
|
|
|
|
|
|
|
urb->transfer_flags = 0;
|
|
|
|
|
|
|
|
usb_fill_bulk_urb(urb, sisusb->sisusb_dev, pipe, data, len,
|
|
|
|
sisusb_bulk_completein, sisusb);
|
|
|
|
|
[PATCH] USB: URB_ASYNC_UNLINK flag removed from the kernel
29 July 2005, Cambridge, MA:
This afternoon Alan Stern submitted a patch to remove the URB_ASYNC_UNLINK
flag from the Linux kernel. Mr. Stern explained, "This flag is a relic
from an earlier, less-well-designed system. For over a year it hasn't
been used for anything other than printing warning messages."
An anonymous spokesman for the Linux kernel development community
commented, "This is exactly the sort of thing we see happening all the
time. As the kernel evolves, support for old techniques and old code can
be jettisoned and replaced by newer, better approaches. Proprietary
operating systems do not have the freedom or flexibility to change so
quickly."
Mr. Stern, a staff member at Harvard University's Rowland Institute who
works on Linux only as a hobby, noted that the patch (labelled as548) did
not update two files, keyspan.c and option.c, in the USB drivers' "serial"
subdirectory. "Those files need more extensive changes," he remarked.
"They examine the status field of several URBs at times when they're not
supposed to. That will need to be fixed before the URB_ASYNC_UNLINK flag
is removed."
Greg Kroah-Hartman, the kernel maintainer responsible for overseeing all
of Linux's USB drivers, did not respond to our inquiries or return our
calls. His only comment was "Applied, thanks."
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-07-30 04:11:07 +08:00
|
|
|
urb->transfer_flags |= tflags;
|
2005-04-17 06:20:36 +08:00
|
|
|
urb->actual_length = 0;
|
|
|
|
|
|
|
|
sisusb->completein = 0;
|
2010-02-20 08:40:54 +08:00
|
|
|
retval = usb_submit_urb(urb, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (retval == 0) {
|
|
|
|
wait_event_timeout(sisusb->wait_q, sisusb->completein, timeout);
|
|
|
|
if (!sisusb->completein) {
|
|
|
|
/* URB timed out... kill it and report error */
|
|
|
|
usb_kill_urb(urb);
|
|
|
|
retval = -ETIMEDOUT;
|
|
|
|
} else {
|
2007-12-18 03:40:18 +08:00
|
|
|
/* URB completed within timeout */
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = urb->status;
|
|
|
|
readbytes = urb->actual_length;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (actual_length)
|
|
|
|
*actual_length = readbytes;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Level 1: */
|
|
|
|
|
|
|
|
/* Send a bulk message of variable size
|
|
|
|
*
|
|
|
|
* To copy the data from userspace, give pointer to "userbuffer",
|
|
|
|
* to copy from (non-DMA) kernel memory, give "kernbuffer". If
|
|
|
|
* both of these are NULL, it is assumed, that the transfer
|
|
|
|
* buffer "sisusb->obuf[index]" is set up with the data to send.
|
|
|
|
* Index is ignored if either kernbuffer or userbuffer is set.
|
|
|
|
* If async is nonzero, URBs will be sent without waiting for
|
|
|
|
* completion of the previous URB.
|
|
|
|
*
|
|
|
|
* (return 0 on success)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int sisusb_send_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
|
|
|
|
char *kernbuffer, const char __user *userbuffer, int index,
|
|
|
|
ssize_t *bytes_written, unsigned int tflags, int async)
|
|
|
|
{
|
|
|
|
int result = 0, retry, count = len;
|
|
|
|
int passsize, thispass, transferred_len = 0;
|
|
|
|
int fromuser = (userbuffer != NULL) ? 1 : 0;
|
|
|
|
int fromkern = (kernbuffer != NULL) ? 1 : 0;
|
|
|
|
unsigned int pipe;
|
|
|
|
char *buffer;
|
|
|
|
|
|
|
|
(*bytes_written) = 0;
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if (!sisusb || !sisusb->present || !sisusb->sisusb_dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* If we copy data from kernel or userspace, force the
|
|
|
|
* allocation of a buffer/urb. If we have the data in
|
|
|
|
* the transfer buffer[index] already, reuse the buffer/URB
|
|
|
|
* if the length is > buffer size. (So, transmitting
|
|
|
|
* large data amounts directly from the transfer buffer
|
|
|
|
* treats the buffer as a ring buffer. However, we need
|
|
|
|
* to sync in this case.)
|
|
|
|
*/
|
|
|
|
if (fromuser || fromkern)
|
|
|
|
index = -1;
|
|
|
|
else if (len > sisusb->obufsize)
|
|
|
|
async = 0;
|
|
|
|
|
|
|
|
pipe = usb_sndbulkpipe(sisusb->sisusb_dev, ep);
|
|
|
|
|
|
|
|
do {
|
|
|
|
passsize = thispass = (sisusb->obufsize < count) ?
|
2016-01-16 01:41:28 +08:00
|
|
|
sisusb->obufsize : count;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (index < 0)
|
|
|
|
index = sisusb_get_free_outbuf(sisusb);
|
|
|
|
|
|
|
|
if (index < 0)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
buffer = sisusb->obuf[index];
|
|
|
|
|
|
|
|
if (fromuser) {
|
|
|
|
|
|
|
|
if (copy_from_user(buffer, userbuffer, passsize))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
userbuffer += passsize;
|
|
|
|
|
|
|
|
} else if (fromkern) {
|
|
|
|
|
|
|
|
memcpy(buffer, kernbuffer, passsize);
|
|
|
|
kernbuffer += passsize;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
retry = 5;
|
|
|
|
while (thispass) {
|
|
|
|
|
|
|
|
if (!sisusb->sisusb_dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
result = sisusb_bulkout_msg(sisusb, index, pipe,
|
|
|
|
buffer, thispass, &transferred_len,
|
|
|
|
async ? 0 : 5 * HZ, tflags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (result == -ETIMEDOUT) {
|
|
|
|
|
|
|
|
/* Will not happen if async */
|
|
|
|
if (!retry--)
|
|
|
|
return -ETIME;
|
|
|
|
|
|
|
|
continue;
|
2009-06-11 04:15:52 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-06-11 04:15:52 +08:00
|
|
|
if ((result == 0) && !async && transferred_len) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
thispass -= transferred_len;
|
2009-06-11 04:15:52 +08:00
|
|
|
buffer += transferred_len;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
} else
|
|
|
|
break;
|
2009-06-11 04:15:52 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
(*bytes_written) += passsize;
|
|
|
|
count -= passsize;
|
|
|
|
|
|
|
|
/* Force new allocation in next iteration */
|
|
|
|
if (fromuser || fromkern)
|
|
|
|
index = -1;
|
|
|
|
|
|
|
|
} while (count > 0);
|
|
|
|
|
|
|
|
if (async) {
|
|
|
|
#ifdef SISUSB_DONTSYNC
|
|
|
|
(*bytes_written) = len;
|
|
|
|
/* Some URBs/buffers might be busy */
|
|
|
|
#else
|
|
|
|
sisusb_wait_all_out_complete(sisusb);
|
|
|
|
(*bytes_written) = transferred_len;
|
|
|
|
/* All URBs and all buffers are available */
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
return ((*bytes_written) == len) ? 0 : -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Receive a bulk message of variable size
|
|
|
|
*
|
|
|
|
* To copy the data to userspace, give pointer to "userbuffer",
|
|
|
|
* to copy to kernel memory, give "kernbuffer". One of them
|
|
|
|
* MUST be set. (There is no technique for letting the caller
|
|
|
|
* read directly from the ibuf.)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int sisusb_recv_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
|
|
|
|
void *kernbuffer, char __user *userbuffer, ssize_t *bytes_read,
|
|
|
|
unsigned int tflags)
|
|
|
|
{
|
|
|
|
int result = 0, retry, count = len;
|
|
|
|
int bufsize, thispass, transferred_len;
|
|
|
|
unsigned int pipe;
|
|
|
|
char *buffer;
|
|
|
|
|
|
|
|
(*bytes_read) = 0;
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if (!sisusb || !sisusb->present || !sisusb->sisusb_dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
pipe = usb_rcvbulkpipe(sisusb->sisusb_dev, ep);
|
|
|
|
buffer = sisusb->ibuf;
|
|
|
|
bufsize = sisusb->ibufsize;
|
|
|
|
|
|
|
|
retry = 5;
|
|
|
|
|
|
|
|
#ifdef SISUSB_DONTSYNC
|
|
|
|
if (!(sisusb_wait_all_out_complete(sisusb)))
|
|
|
|
return -EIO;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
while (count > 0) {
|
|
|
|
|
|
|
|
if (!sisusb->sisusb_dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
thispass = (bufsize < count) ? bufsize : count;
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
result = sisusb_bulkin_msg(sisusb, pipe, buffer, thispass,
|
|
|
|
&transferred_len, 5 * HZ, tflags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (transferred_len)
|
|
|
|
thispass = transferred_len;
|
|
|
|
|
|
|
|
else if (result == -ETIMEDOUT) {
|
|
|
|
|
|
|
|
if (!retry--)
|
|
|
|
return -ETIME;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
} else
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
|
|
|
|
if (thispass) {
|
|
|
|
|
|
|
|
(*bytes_read) += thispass;
|
|
|
|
count -= thispass;
|
|
|
|
|
|
|
|
if (userbuffer) {
|
|
|
|
|
|
|
|
if (copy_to_user(userbuffer, buffer, thispass))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
userbuffer += thispass;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
memcpy(kernbuffer, buffer, thispass);
|
|
|
|
kernbuffer += thispass;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return ((*bytes_read) == len) ? 0 : -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_send_packet(struct sisusb_usb_data *sisusb, int len,
|
2016-01-16 01:41:28 +08:00
|
|
|
struct sisusb_packet *packet)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
ssize_t bytes_transferred = 0;
|
|
|
|
__le32 tmp;
|
|
|
|
|
|
|
|
if (len == 6)
|
|
|
|
packet->data = 0;
|
|
|
|
|
|
|
|
#ifdef SISUSB_DONTSYNC
|
|
|
|
if (!(sisusb_wait_all_out_complete(sisusb)))
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Eventually correct endianness */
|
|
|
|
SISUSB_CORRECT_ENDIANNESS_PACKET(packet);
|
|
|
|
|
|
|
|
/* 1. send the packet */
|
|
|
|
ret = sisusb_send_bulk_msg(sisusb, SISUSB_EP_GFX_OUT, len,
|
|
|
|
(char *)packet, NULL, 0, &bytes_transferred, 0, 0);
|
|
|
|
|
|
|
|
if ((ret == 0) && (len == 6)) {
|
|
|
|
|
|
|
|
/* 2. if packet len == 6, it means we read, so wait for 32bit
|
|
|
|
* return value and write it to packet->data
|
|
|
|
*/
|
|
|
|
ret = sisusb_recv_bulk_msg(sisusb, SISUSB_EP_GFX_IN, 4,
|
|
|
|
(char *)&tmp, NULL, &bytes_transferred, 0);
|
|
|
|
|
|
|
|
packet->data = le32_to_cpu(tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_send_bridge_packet(struct sisusb_usb_data *sisusb, int len,
|
2016-01-16 01:41:29 +08:00
|
|
|
struct sisusb_packet *packet, unsigned int tflags)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
ssize_t bytes_transferred = 0;
|
|
|
|
__le32 tmp;
|
|
|
|
|
|
|
|
if (len == 6)
|
|
|
|
packet->data = 0;
|
|
|
|
|
|
|
|
#ifdef SISUSB_DONTSYNC
|
|
|
|
if (!(sisusb_wait_all_out_complete(sisusb)))
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Eventually correct endianness */
|
|
|
|
SISUSB_CORRECT_ENDIANNESS_PACKET(packet);
|
|
|
|
|
|
|
|
/* 1. send the packet */
|
|
|
|
ret = sisusb_send_bulk_msg(sisusb, SISUSB_EP_BRIDGE_OUT, len,
|
|
|
|
(char *)packet, NULL, 0, &bytes_transferred, tflags, 0);
|
|
|
|
|
|
|
|
if ((ret == 0) && (len == 6)) {
|
|
|
|
|
|
|
|
/* 2. if packet len == 6, it means we read, so wait for 32bit
|
|
|
|
* return value and write it to packet->data
|
|
|
|
*/
|
|
|
|
ret = sisusb_recv_bulk_msg(sisusb, SISUSB_EP_BRIDGE_IN, 4,
|
|
|
|
(char *)&tmp, NULL, &bytes_transferred, 0);
|
|
|
|
|
|
|
|
packet->data = le32_to_cpu(tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* access video memory and mmio (return 0 on success) */
|
|
|
|
|
|
|
|
/* Low level */
|
|
|
|
|
|
|
|
/* The following routines assume being used to transfer byte, word,
|
|
|
|
* long etc.
|
2005-08-29 23:01:16 +08:00
|
|
|
* This means that
|
|
|
|
* - the write routines expect "data" in machine endianness format.
|
|
|
|
* The data will be converted to leXX in sisusb_xxx_packet.
|
|
|
|
* - the read routines can expect read data in machine-endianess.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int sisusb_write_memio_byte(struct sisusb_usb_data *sisusb, int type,
|
2016-01-16 01:41:28 +08:00
|
|
|
u32 addr, u8 data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
|
|
|
|
packet.header = (1 << (addr & 3)) | (type << 6);
|
|
|
|
packet.address = addr & ~3;
|
|
|
|
packet.data = data << ((addr & 3) << 3);
|
2017-07-10 11:31:31 +08:00
|
|
|
return sisusb_send_packet(sisusb, 10, &packet);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_write_memio_word(struct sisusb_usb_data *sisusb, int type,
|
2016-01-16 01:41:28 +08:00
|
|
|
u32 addr, u16 data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
packet.address = addr & ~3;
|
|
|
|
|
|
|
|
switch (addr & 3) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case 0:
|
|
|
|
packet.header = (type << 6) | 0x0003;
|
|
|
|
packet.data = (u32)data;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
packet.header = (type << 6) | 0x0006;
|
|
|
|
packet.data = (u32)data << 8;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
packet.header = (type << 6) | 0x000c;
|
|
|
|
packet.data = (u32)data << 16;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
packet.header = (type << 6) | 0x0008;
|
|
|
|
packet.data = (u32)data << 24;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
packet.header = (type << 6) | 0x0001;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
packet.data = (u32)data >> 8;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 10, &packet);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_write_memio_24bit(struct sisusb_usb_data *sisusb, int type,
|
2016-01-16 01:41:28 +08:00
|
|
|
u32 addr, u32 data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
packet.address = addr & ~3;
|
|
|
|
|
|
|
|
switch (addr & 3) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case 0:
|
|
|
|
packet.header = (type << 6) | 0x0007;
|
|
|
|
packet.data = data & 0x00ffffff;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
packet.header = (type << 6) | 0x000e;
|
|
|
|
packet.data = data << 8;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
packet.header = (type << 6) | 0x000c;
|
|
|
|
packet.data = data << 16;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
packet.header = (type << 6) | 0x0001;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
packet.data = (data >> 16) & 0x00ff;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
packet.header = (type << 6) | 0x0008;
|
|
|
|
packet.data = data << 24;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
packet.header = (type << 6) | 0x0003;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
packet.data = (data >> 8) & 0xffff;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 10, &packet);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_write_memio_long(struct sisusb_usb_data *sisusb, int type,
|
2016-01-16 01:41:28 +08:00
|
|
|
u32 addr, u32 data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
packet.address = addr & ~3;
|
|
|
|
|
|
|
|
switch (addr & 3) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case 0:
|
|
|
|
packet.header = (type << 6) | 0x000f;
|
|
|
|
packet.data = data;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
packet.header = (type << 6) | 0x000e;
|
|
|
|
packet.data = data << 8;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
packet.header = (type << 6) | 0x0001;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
packet.data = data >> 24;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
packet.header = (type << 6) | 0x000c;
|
|
|
|
packet.data = data << 16;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
packet.header = (type << 6) | 0x0003;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
packet.data = data >> 16;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
packet.header = (type << 6) | 0x0008;
|
|
|
|
packet.data = data << 24;
|
|
|
|
ret = sisusb_send_packet(sisusb, 10, &packet);
|
|
|
|
packet.header = (type << 6) | 0x0007;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
packet.data = data >> 8;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 10, &packet);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The xxx_bulk routines copy a buffer of variable size. They treat the
|
|
|
|
* buffer as chars, therefore lsb/msb has to be corrected if using the
|
|
|
|
* byte/word/long/etc routines for speed-up
|
|
|
|
*
|
|
|
|
* If data is from userland, set "userbuffer" (and clear "kernbuffer"),
|
|
|
|
* if data is in kernel space, set "kernbuffer" (and clear "userbuffer");
|
|
|
|
* if neither "kernbuffer" nor "userbuffer" are given, it is assumed
|
|
|
|
* that the data already is in the transfer buffer "sisusb->obuf[index]".
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
|
2016-01-16 01:41:29 +08:00
|
|
|
char *kernbuffer, int length, const char __user *userbuffer,
|
|
|
|
int index, ssize_t *bytes_written)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret = 0;
|
2016-01-16 01:41:30 +08:00
|
|
|
static int msgcount;
|
2005-04-17 06:20:36 +08:00
|
|
|
u8 swap8, fromkern = kernbuffer ? 1 : 0;
|
|
|
|
u16 swap16;
|
|
|
|
u32 swap32, flag = (length >> 28) & 1;
|
2020-07-11 12:30:18 +08:00
|
|
|
u8 buf[4];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* if neither kernbuffer not userbuffer are given, assume
|
|
|
|
* data in obuf
|
|
|
|
*/
|
|
|
|
if (!fromkern && !userbuffer)
|
|
|
|
kernbuffer = sisusb->obuf[index];
|
|
|
|
|
|
|
|
(*bytes_written = 0);
|
|
|
|
|
|
|
|
length &= 0x00ffffff;
|
|
|
|
|
|
|
|
while (length) {
|
2016-01-16 01:41:28 +08:00
|
|
|
switch (length) {
|
2005-04-17 06:20:36 +08:00
|
|
|
case 1:
|
|
|
|
if (userbuffer) {
|
|
|
|
if (get_user(swap8, (u8 __user *)userbuffer))
|
|
|
|
return -EFAULT;
|
|
|
|
} else
|
|
|
|
swap8 = kernbuffer[0];
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM,
|
|
|
|
addr, swap8);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
(*bytes_written)++;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
if (userbuffer) {
|
|
|
|
if (get_user(swap16, (u16 __user *)userbuffer))
|
|
|
|
return -EFAULT;
|
|
|
|
} else
|
2005-08-29 23:01:16 +08:00
|
|
|
swap16 = *((u16 *)kernbuffer);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
ret = sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
|
|
|
|
addr, swap16);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
(*bytes_written) += 2;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
if (userbuffer) {
|
|
|
|
if (copy_from_user(&buf, userbuffer, 3))
|
|
|
|
return -EFAULT;
|
2005-08-29 23:01:16 +08:00
|
|
|
#ifdef __BIG_ENDIAN
|
2005-04-17 06:20:36 +08:00
|
|
|
swap32 = (buf[0] << 16) |
|
|
|
|
(buf[1] << 8) |
|
|
|
|
buf[2];
|
2005-08-29 23:01:16 +08:00
|
|
|
#else
|
|
|
|
swap32 = (buf[2] << 16) |
|
|
|
|
(buf[1] << 8) |
|
|
|
|
buf[0];
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
} else
|
2005-08-29 23:01:16 +08:00
|
|
|
#ifdef __BIG_ENDIAN
|
2005-04-17 06:20:36 +08:00
|
|
|
swap32 = (kernbuffer[0] << 16) |
|
|
|
|
(kernbuffer[1] << 8) |
|
|
|
|
kernbuffer[2];
|
2005-08-29 23:01:16 +08:00
|
|
|
#else
|
|
|
|
swap32 = (kernbuffer[2] << 16) |
|
|
|
|
(kernbuffer[1] << 8) |
|
|
|
|
kernbuffer[0];
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
ret = sisusb_write_memio_24bit(sisusb, SISUSB_TYPE_MEM,
|
|
|
|
addr, swap32);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
(*bytes_written) += 3;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
if (userbuffer) {
|
|
|
|
if (get_user(swap32, (u32 __user *)userbuffer))
|
|
|
|
return -EFAULT;
|
|
|
|
} else
|
2005-08-29 23:01:16 +08:00
|
|
|
swap32 = *((u32 *)kernbuffer);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
ret = sisusb_write_memio_long(sisusb, SISUSB_TYPE_MEM,
|
|
|
|
addr, swap32);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!ret)
|
|
|
|
(*bytes_written) += 4;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
default:
|
|
|
|
if ((length & ~3) > 0x10000) {
|
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x000001d4;
|
|
|
|
packet.data = addr;
|
|
|
|
ret = sisusb_send_bridge_packet(sisusb, 10,
|
|
|
|
&packet, 0);
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x000001d0;
|
|
|
|
packet.data = (length & ~3);
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 10,
|
|
|
|
&packet, 0);
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x000001c0;
|
|
|
|
packet.data = flag | 0x16;
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 10,
|
|
|
|
&packet, 0);
|
|
|
|
if (userbuffer) {
|
|
|
|
ret |= sisusb_send_bulk_msg(sisusb,
|
2005-04-17 06:20:36 +08:00
|
|
|
SISUSB_EP_GFX_LBULK_OUT,
|
|
|
|
(length & ~3),
|
|
|
|
NULL, userbuffer, 0,
|
|
|
|
bytes_written, 0, 1);
|
2016-01-16 01:41:28 +08:00
|
|
|
userbuffer += (*bytes_written);
|
|
|
|
} else if (fromkern) {
|
|
|
|
ret |= sisusb_send_bulk_msg(sisusb,
|
2005-04-17 06:20:36 +08:00
|
|
|
SISUSB_EP_GFX_LBULK_OUT,
|
|
|
|
(length & ~3),
|
|
|
|
kernbuffer, NULL, 0,
|
|
|
|
bytes_written, 0, 1);
|
2016-01-16 01:41:28 +08:00
|
|
|
kernbuffer += (*bytes_written);
|
|
|
|
} else {
|
|
|
|
ret |= sisusb_send_bulk_msg(sisusb,
|
2005-04-17 06:20:36 +08:00
|
|
|
SISUSB_EP_GFX_LBULK_OUT,
|
|
|
|
(length & ~3),
|
|
|
|
NULL, NULL, index,
|
|
|
|
bytes_written, 0, 1);
|
2016-01-16 01:41:28 +08:00
|
|
|
kernbuffer += ((*bytes_written) &
|
|
|
|
(sisusb->obufsize-1));
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
packet.header = 0x001f;
|
2016-01-16 01:41:28 +08:00
|
|
|
packet.address = 0x00000194;
|
|
|
|
packet.data = addr;
|
|
|
|
ret = sisusb_send_bridge_packet(sisusb, 10,
|
|
|
|
&packet, 0);
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x00000190;
|
|
|
|
packet.data = (length & ~3);
|
2005-04-17 06:20:36 +08:00
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 10,
|
2016-01-16 01:41:28 +08:00
|
|
|
&packet, 0);
|
|
|
|
if (sisusb->flagb0 != 0x16) {
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x00000180;
|
|
|
|
packet.data = flag | 0x16;
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb,
|
|
|
|
10, &packet, 0);
|
|
|
|
sisusb->flagb0 = 0x16;
|
|
|
|
}
|
|
|
|
if (userbuffer) {
|
|
|
|
ret |= sisusb_send_bulk_msg(sisusb,
|
2005-04-17 06:20:36 +08:00
|
|
|
SISUSB_EP_GFX_BULK_OUT,
|
|
|
|
(length & ~3),
|
|
|
|
NULL, userbuffer, 0,
|
|
|
|
bytes_written, 0, 1);
|
2016-01-16 01:41:28 +08:00
|
|
|
userbuffer += (*bytes_written);
|
|
|
|
} else if (fromkern) {
|
|
|
|
ret |= sisusb_send_bulk_msg(sisusb,
|
2005-04-17 06:20:36 +08:00
|
|
|
SISUSB_EP_GFX_BULK_OUT,
|
|
|
|
(length & ~3),
|
|
|
|
kernbuffer, NULL, 0,
|
|
|
|
bytes_written, 0, 1);
|
2016-01-16 01:41:28 +08:00
|
|
|
kernbuffer += (*bytes_written);
|
|
|
|
} else {
|
|
|
|
ret |= sisusb_send_bulk_msg(sisusb,
|
2005-04-17 06:20:36 +08:00
|
|
|
SISUSB_EP_GFX_BULK_OUT,
|
|
|
|
(length & ~3),
|
|
|
|
NULL, NULL, index,
|
|
|
|
bytes_written, 0, 1);
|
2016-01-16 01:41:28 +08:00
|
|
|
kernbuffer += ((*bytes_written) &
|
|
|
|
(sisusb->obufsize-1));
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (ret) {
|
|
|
|
msgcount++;
|
|
|
|
if (msgcount < 500)
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_err(&sisusb->sisusb_dev->dev,
|
|
|
|
"Wrote %zd of %d bytes, error %d\n",
|
|
|
|
*bytes_written, length,
|
|
|
|
ret);
|
2005-04-17 06:20:36 +08:00
|
|
|
else if (msgcount == 500)
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_err(&sisusb->sisusb_dev->dev,
|
|
|
|
"Too many errors, logging stopped\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
addr += (*bytes_written);
|
|
|
|
length -= (*bytes_written);
|
2016-01-16 01:41:28 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
if (ret)
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret ? -EIO : 0;
|
|
|
|
}
|
|
|
|
|
2005-08-29 23:01:16 +08:00
|
|
|
/* Remember: Read data in packet is in machine-endianess! So for
|
|
|
|
* byte, word, 24bit, long no endian correction is necessary.
|
|
|
|
*/
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static int sisusb_read_memio_byte(struct sisusb_usb_data *sisusb, int type,
|
2016-01-16 01:41:28 +08:00
|
|
|
u32 addr, u8 *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
CLEARPACKET(&packet);
|
|
|
|
packet.header = (1 << (addr & 3)) | (type << 6);
|
|
|
|
packet.address = addr & ~3;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = (u8)(packet.data >> ((addr & 3) << 3));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_read_memio_word(struct sisusb_usb_data *sisusb, int type,
|
2016-01-16 01:41:28 +08:00
|
|
|
u32 addr, u16 *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
CLEARPACKET(&packet);
|
|
|
|
|
|
|
|
packet.address = addr & ~3;
|
|
|
|
|
|
|
|
switch (addr & 3) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case 0:
|
|
|
|
packet.header = (type << 6) | 0x0003;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = (u16)(packet.data);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
packet.header = (type << 6) | 0x0006;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = (u16)(packet.data >> 8);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
packet.header = (type << 6) | 0x000c;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = (u16)(packet.data >> 16);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
packet.header = (type << 6) | 0x0008;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = (u16)(packet.data >> 24);
|
|
|
|
packet.header = (type << 6) | 0x0001;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data |= (u16)(packet.data << 8);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_read_memio_24bit(struct sisusb_usb_data *sisusb, int type,
|
2016-01-16 01:41:28 +08:00
|
|
|
u32 addr, u32 *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
packet.address = addr & ~3;
|
|
|
|
|
|
|
|
switch (addr & 3) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case 0:
|
|
|
|
packet.header = (type << 6) | 0x0007;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data & 0x00ffffff;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
packet.header = (type << 6) | 0x000e;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data >> 8;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
packet.header = (type << 6) | 0x000c;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data >> 16;
|
|
|
|
packet.header = (type << 6) | 0x0001;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data |= ((packet.data & 0xff) << 16);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
packet.header = (type << 6) | 0x0008;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data >> 24;
|
|
|
|
packet.header = (type << 6) | 0x0003;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data |= ((packet.data & 0xffff) << 8);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_read_memio_long(struct sisusb_usb_data *sisusb, int type,
|
2016-01-16 01:41:28 +08:00
|
|
|
u32 addr, u32 *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
packet.address = addr & ~3;
|
|
|
|
|
|
|
|
switch (addr & 3) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case 0:
|
|
|
|
packet.header = (type << 6) | 0x000f;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
packet.header = (type << 6) | 0x000e;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data >> 8;
|
|
|
|
packet.header = (type << 6) | 0x0001;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data |= (packet.data << 24);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
packet.header = (type << 6) | 0x000c;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data >> 16;
|
|
|
|
packet.header = (type << 6) | 0x0003;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data |= (packet.data << 16);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
packet.header = (type << 6) | 0x0008;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data >> 24;
|
|
|
|
packet.header = (type << 6) | 0x0007;
|
|
|
|
packet.address = (addr & ~3) + 4;
|
|
|
|
ret |= sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data |= (packet.data << 8);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
|
2016-01-16 01:41:29 +08:00
|
|
|
char *kernbuffer, int length, char __user *userbuffer,
|
|
|
|
ssize_t *bytes_read)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
char buf[4];
|
|
|
|
u16 swap16;
|
|
|
|
u32 swap32;
|
|
|
|
|
|
|
|
(*bytes_read = 0);
|
|
|
|
|
|
|
|
length &= 0x00ffffff;
|
|
|
|
|
|
|
|
while (length) {
|
2016-01-16 01:41:28 +08:00
|
|
|
switch (length) {
|
2005-04-17 06:20:36 +08:00
|
|
|
case 1:
|
|
|
|
ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM,
|
2016-01-16 01:41:28 +08:00
|
|
|
addr, &buf[0]);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!ret) {
|
|
|
|
(*bytes_read)++;
|
|
|
|
if (userbuffer) {
|
2016-01-16 01:41:30 +08:00
|
|
|
if (put_user(buf[0], (u8 __user *)userbuffer))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EFAULT;
|
2016-01-16 01:41:30 +08:00
|
|
|
} else
|
2005-04-17 06:20:36 +08:00
|
|
|
kernbuffer[0] = buf[0];
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
ret |= sisusb_read_memio_word(sisusb, SISUSB_TYPE_MEM,
|
2016-01-16 01:41:28 +08:00
|
|
|
addr, &swap16);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!ret) {
|
|
|
|
(*bytes_read) += 2;
|
|
|
|
if (userbuffer) {
|
2016-01-16 01:41:29 +08:00
|
|
|
if (put_user(swap16, (u16 __user *)userbuffer))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EFAULT;
|
|
|
|
} else {
|
2005-08-29 23:01:16 +08:00
|
|
|
*((u16 *)kernbuffer) = swap16;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
ret |= sisusb_read_memio_24bit(sisusb, SISUSB_TYPE_MEM,
|
2016-01-16 01:41:28 +08:00
|
|
|
addr, &swap32);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!ret) {
|
|
|
|
(*bytes_read) += 3;
|
2005-08-29 23:01:16 +08:00
|
|
|
#ifdef __BIG_ENDIAN
|
2005-04-17 06:20:36 +08:00
|
|
|
buf[0] = (swap32 >> 16) & 0xff;
|
|
|
|
buf[1] = (swap32 >> 8) & 0xff;
|
|
|
|
buf[2] = swap32 & 0xff;
|
2005-08-29 23:01:16 +08:00
|
|
|
#else
|
|
|
|
buf[2] = (swap32 >> 16) & 0xff;
|
|
|
|
buf[1] = (swap32 >> 8) & 0xff;
|
|
|
|
buf[0] = swap32 & 0xff;
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
if (userbuffer) {
|
2016-01-16 01:41:29 +08:00
|
|
|
if (copy_to_user(userbuffer,
|
|
|
|
&buf[0], 3))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EFAULT;
|
|
|
|
} else {
|
|
|
|
kernbuffer[0] = buf[0];
|
|
|
|
kernbuffer[1] = buf[1];
|
|
|
|
kernbuffer[2] = buf[2];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ret |= sisusb_read_memio_long(sisusb, SISUSB_TYPE_MEM,
|
2016-01-16 01:41:28 +08:00
|
|
|
addr, &swap32);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!ret) {
|
|
|
|
(*bytes_read) += 4;
|
|
|
|
if (userbuffer) {
|
2016-01-16 01:41:29 +08:00
|
|
|
if (put_user(swap32, (u32 __user *)userbuffer))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
userbuffer += 4;
|
|
|
|
} else {
|
2005-08-29 23:01:16 +08:00
|
|
|
*((u32 *)kernbuffer) = swap32;
|
2005-04-17 06:20:36 +08:00
|
|
|
kernbuffer += 4;
|
|
|
|
}
|
|
|
|
addr += 4;
|
|
|
|
length -= 4;
|
|
|
|
}
|
2016-01-16 01:41:28 +08:00
|
|
|
}
|
|
|
|
if (ret)
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* High level: Gfx (indexed) register access */
|
|
|
|
|
2022-12-08 17:07:46 +08:00
|
|
|
static int sisusb_setidxreg(struct sisusb_usb_data *sisusb, u32 port,
|
2016-01-16 01:41:29 +08:00
|
|
|
u8 index, u8 data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
2016-01-16 01:41:29 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, index);
|
|
|
|
ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, data);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-12-08 17:07:46 +08:00
|
|
|
static int sisusb_getidxreg(struct sisusb_usb_data *sisusb, u32 port,
|
2016-01-16 01:41:29 +08:00
|
|
|
u8 index, u8 *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
2016-01-16 01:41:29 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, index);
|
|
|
|
ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, data);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-12-08 17:07:46 +08:00
|
|
|
static int sisusb_setidxregandor(struct sisusb_usb_data *sisusb, u32 port, u8 idx,
|
2016-01-16 01:41:29 +08:00
|
|
|
u8 myand, u8 myor)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 tmp;
|
|
|
|
|
|
|
|
ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, idx);
|
|
|
|
ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, &tmp);
|
|
|
|
tmp &= myand;
|
|
|
|
tmp |= myor;
|
|
|
|
ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, tmp);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_setidxregmask(struct sisusb_usb_data *sisusb,
|
2020-04-21 11:41:25 +08:00
|
|
|
u32 port, u8 idx, u8 data, u8 mask)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 tmp;
|
2016-01-16 01:41:29 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, idx);
|
|
|
|
ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, &tmp);
|
|
|
|
tmp &= ~(mask);
|
|
|
|
tmp |= (data & mask);
|
|
|
|
ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, tmp);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-12-08 17:07:46 +08:00
|
|
|
static int sisusb_setidxregor(struct sisusb_usb_data *sisusb, u32 port,
|
2016-01-16 01:41:29 +08:00
|
|
|
u8 index, u8 myor)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2016-01-16 01:41:30 +08:00
|
|
|
return sisusb_setidxregandor(sisusb, port, index, 0xff, myor);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2022-12-08 17:07:46 +08:00
|
|
|
static int sisusb_setidxregand(struct sisusb_usb_data *sisusb, u32 port,
|
2016-01-16 01:41:29 +08:00
|
|
|
u8 idx, u8 myand)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2016-01-16 01:41:30 +08:00
|
|
|
return sisusb_setidxregandor(sisusb, port, idx, myand, 0x00);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-08-29 23:01:16 +08:00
|
|
|
/* Write/read video ram */
|
|
|
|
|
|
|
|
#ifdef SISUSBENDIANTEST
|
2016-01-16 01:41:29 +08:00
|
|
|
static void sisusb_testreadwrite(struct sisusb_usb_data *sisusb)
|
2005-08-29 23:01:16 +08:00
|
|
|
{
|
2020-05-30 09:48:15 +08:00
|
|
|
static u8 srcbuffer[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
|
2016-01-16 01:41:28 +08:00
|
|
|
char destbuffer[10];
|
|
|
|
int i, j;
|
|
|
|
|
2016-06-23 19:34:25 +08:00
|
|
|
sisusb_copy_memory(sisusb, srcbuffer, sisusb->vrambase, 7);
|
2016-01-16 01:41:28 +08:00
|
|
|
|
|
|
|
for (i = 1; i <= 7; i++) {
|
|
|
|
dev_dbg(&sisusb->sisusb_dev->dev,
|
|
|
|
"sisusb: rwtest %d bytes\n", i);
|
2016-06-23 19:34:25 +08:00
|
|
|
sisusb_read_memory(sisusb, destbuffer, sisusb->vrambase, i);
|
2016-01-16 01:41:28 +08:00
|
|
|
for (j = 0; j < i; j++) {
|
|
|
|
dev_dbg(&sisusb->sisusb_dev->dev,
|
|
|
|
"rwtest read[%d] = %x\n",
|
|
|
|
j, destbuffer[j]);
|
|
|
|
}
|
2005-08-29 23:01:16 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* access pci config registers (reg numbers 0, 4, 8, etc) */
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_write_pci_config(struct sisusb_usb_data *sisusb,
|
|
|
|
int regnum, u32 data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
|
|
|
|
packet.header = 0x008f;
|
|
|
|
packet.address = regnum | 0x10000;
|
|
|
|
packet.data = data;
|
2017-07-10 11:31:31 +08:00
|
|
|
return sisusb_send_packet(sisusb, 10, &packet);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_read_pci_config(struct sisusb_usb_data *sisusb,
|
|
|
|
int regnum, u32 *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
packet.header = 0x008f;
|
|
|
|
packet.address = (u32)regnum | 0x10000;
|
|
|
|
ret = sisusb_send_packet(sisusb, 6, &packet);
|
|
|
|
*data = packet.data;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clear video RAM */
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_clear_vram(struct sisusb_usb_data *sisusb,
|
|
|
|
u32 address, int length)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
ssize_t j;
|
|
|
|
|
|
|
|
if (address < sisusb->vrambase)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (address >= sisusb->vrambase + sisusb->vramsize)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (address + length > sisusb->vrambase + sisusb->vramsize)
|
|
|
|
length = sisusb->vrambase + sisusb->vramsize - address;
|
|
|
|
|
|
|
|
if (length <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* allocate free buffer/urb and clear the buffer */
|
2016-01-16 01:41:31 +08:00
|
|
|
i = sisusb_alloc_outbuf(sisusb);
|
|
|
|
if (i < 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
memset(sisusb->obuf[i], 0, sisusb->obufsize);
|
|
|
|
|
|
|
|
/* We can write a length > buffer size here. The buffer
|
|
|
|
* data will simply be re-used (like a ring-buffer).
|
|
|
|
*/
|
|
|
|
ret = sisusb_write_mem_bulk(sisusb, address, NULL, length, NULL, i, &j);
|
|
|
|
|
|
|
|
/* Free the buffer/urb */
|
|
|
|
sisusb_free_outbuf(sisusb, i);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the graphics core (return 0 on success)
|
|
|
|
* This resets the graphics hardware and puts it into
|
|
|
|
* a defined mode (640x480@60Hz)
|
|
|
|
*/
|
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
#define GETREG(r, d) sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, r, d)
|
|
|
|
#define SETREG(r, d) sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, r, d)
|
|
|
|
#define SETIREG(r, i, d) sisusb_setidxreg(sisusb, r, i, d)
|
|
|
|
#define GETIREG(r, i, d) sisusb_getidxreg(sisusb, r, i, d)
|
|
|
|
#define SETIREGOR(r, i, o) sisusb_setidxregor(sisusb, r, i, o)
|
|
|
|
#define SETIREGAND(r, i, a) sisusb_setidxregand(sisusb, r, i, a)
|
|
|
|
#define SETIREGANDOR(r, i, a, o) sisusb_setidxregandor(sisusb, r, i, a, o)
|
|
|
|
#define READL(a, d) sisusb_read_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
|
|
|
|
#define WRITEL(a, d) sisusb_write_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
|
|
|
|
#define READB(a, d) sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
|
|
|
|
#define WRITEB(a, d) sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_triggersr16(struct sisusb_usb_data *sisusb, u8 ramtype)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 tmp8;
|
|
|
|
|
|
|
|
ret = GETIREG(SISSR, 0x16, &tmp8);
|
|
|
|
if (ramtype <= 1) {
|
|
|
|
tmp8 &= 0x3f;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
tmp8 |= 0x80;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
} else {
|
|
|
|
tmp8 |= 0xc0;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
tmp8 &= 0x0f;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
tmp8 |= 0x80;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
tmp8 &= 0x0f;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
tmp8 |= 0xd0;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
tmp8 &= 0x0f;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
tmp8 |= 0xa0;
|
|
|
|
ret |= SETIREG(SISSR, 0x16, tmp8);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_getbuswidth(struct sisusb_usb_data *sisusb,
|
|
|
|
int *bw, int *chab)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 ramtype, done = 0;
|
|
|
|
u32 t0, t1, t2, t3;
|
|
|
|
u32 ramptr = SISUSB_PCI_MEMBASE;
|
|
|
|
|
|
|
|
ret = GETIREG(SISSR, 0x3a, &ramtype);
|
|
|
|
ramtype &= 3;
|
|
|
|
|
|
|
|
ret |= SETIREG(SISSR, 0x13, 0x00);
|
|
|
|
|
|
|
|
if (ramtype <= 1) {
|
|
|
|
ret |= SETIREG(SISSR, 0x14, 0x12);
|
|
|
|
ret |= SETIREGAND(SISSR, 0x15, 0xef);
|
|
|
|
} else {
|
|
|
|
ret |= SETIREG(SISSR, 0x14, 0x02);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret |= sisusb_triggersr16(sisusb, ramtype);
|
|
|
|
ret |= WRITEL(ramptr + 0, 0x01234567);
|
|
|
|
ret |= WRITEL(ramptr + 4, 0x456789ab);
|
|
|
|
ret |= WRITEL(ramptr + 8, 0x89abcdef);
|
|
|
|
ret |= WRITEL(ramptr + 12, 0xcdef0123);
|
|
|
|
ret |= WRITEL(ramptr + 16, 0x55555555);
|
|
|
|
ret |= WRITEL(ramptr + 20, 0x55555555);
|
|
|
|
ret |= WRITEL(ramptr + 24, 0xffffffff);
|
|
|
|
ret |= WRITEL(ramptr + 28, 0xffffffff);
|
|
|
|
ret |= READL(ramptr + 0, &t0);
|
|
|
|
ret |= READL(ramptr + 4, &t1);
|
|
|
|
ret |= READL(ramptr + 8, &t2);
|
|
|
|
ret |= READL(ramptr + 12, &t3);
|
|
|
|
|
|
|
|
if (ramtype <= 1) {
|
|
|
|
|
|
|
|
*chab = 0; *bw = 64;
|
|
|
|
|
|
|
|
if ((t3 != 0xcdef0123) || (t2 != 0x89abcdef)) {
|
|
|
|
if ((t1 == 0x456789ab) && (t0 == 0x01234567)) {
|
|
|
|
*chab = 0; *bw = 64;
|
|
|
|
ret |= SETIREGAND(SISSR, 0x14, 0xfd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((t1 != 0x456789ab) || (t0 != 0x01234567)) {
|
|
|
|
*chab = 1; *bw = 64;
|
2016-01-16 01:41:28 +08:00
|
|
|
ret |= SETIREGANDOR(SISSR, 0x14, 0xfc, 0x01);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret |= sisusb_triggersr16(sisusb, ramtype);
|
|
|
|
ret |= WRITEL(ramptr + 0, 0x89abcdef);
|
|
|
|
ret |= WRITEL(ramptr + 4, 0xcdef0123);
|
|
|
|
ret |= WRITEL(ramptr + 8, 0x55555555);
|
|
|
|
ret |= WRITEL(ramptr + 12, 0x55555555);
|
|
|
|
ret |= WRITEL(ramptr + 16, 0xaaaaaaaa);
|
|
|
|
ret |= WRITEL(ramptr + 20, 0xaaaaaaaa);
|
|
|
|
ret |= READL(ramptr + 4, &t1);
|
|
|
|
|
|
|
|
if (t1 != 0xcdef0123) {
|
|
|
|
*bw = 32;
|
|
|
|
ret |= SETIREGOR(SISSR, 0x15, 0x10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
*chab = 0; *bw = 64; /* default: cha, bw = 64 */
|
|
|
|
|
|
|
|
done = 0;
|
|
|
|
|
|
|
|
if (t1 == 0x456789ab) {
|
|
|
|
if (t0 == 0x01234567) {
|
|
|
|
*chab = 0; *bw = 64;
|
|
|
|
done = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (t0 == 0x01234567) {
|
|
|
|
*chab = 0; *bw = 32;
|
|
|
|
ret |= SETIREG(SISSR, 0x14, 0x00);
|
|
|
|
done = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!done) {
|
|
|
|
ret |= SETIREG(SISSR, 0x14, 0x03);
|
|
|
|
ret |= sisusb_triggersr16(sisusb, ramtype);
|
|
|
|
|
|
|
|
ret |= WRITEL(ramptr + 0, 0x01234567);
|
|
|
|
ret |= WRITEL(ramptr + 4, 0x456789ab);
|
|
|
|
ret |= WRITEL(ramptr + 8, 0x89abcdef);
|
|
|
|
ret |= WRITEL(ramptr + 12, 0xcdef0123);
|
|
|
|
ret |= WRITEL(ramptr + 16, 0x55555555);
|
|
|
|
ret |= WRITEL(ramptr + 20, 0x55555555);
|
|
|
|
ret |= WRITEL(ramptr + 24, 0xffffffff);
|
|
|
|
ret |= WRITEL(ramptr + 28, 0xffffffff);
|
|
|
|
ret |= READL(ramptr + 0, &t0);
|
|
|
|
ret |= READL(ramptr + 4, &t1);
|
|
|
|
|
|
|
|
if (t1 == 0x456789ab) {
|
|
|
|
if (t0 == 0x01234567) {
|
|
|
|
*chab = 1; *bw = 64;
|
|
|
|
return ret;
|
|
|
|
} /* else error */
|
|
|
|
} else {
|
|
|
|
if (t0 == 0x01234567) {
|
|
|
|
*chab = 1; *bw = 32;
|
|
|
|
ret |= SETIREG(SISSR, 0x14, 0x01);
|
|
|
|
} /* else error */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_verify_mclk(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
u32 ramptr = SISUSB_PCI_MEMBASE;
|
|
|
|
u8 tmp1, tmp2, i, j;
|
|
|
|
|
|
|
|
ret |= WRITEB(ramptr, 0xaa);
|
|
|
|
ret |= WRITEB(ramptr + 16, 0x55);
|
|
|
|
ret |= READB(ramptr, &tmp1);
|
|
|
|
ret |= READB(ramptr + 16, &tmp2);
|
|
|
|
if ((tmp1 != 0xaa) || (tmp2 != 0x55)) {
|
|
|
|
for (i = 0, j = 16; i < 2; i++, j += 16) {
|
|
|
|
ret |= GETIREG(SISSR, 0x21, &tmp1);
|
|
|
|
ret |= SETIREGAND(SISSR, 0x21, (tmp1 & 0xfb));
|
|
|
|
ret |= SETIREGOR(SISSR, 0x3c, 0x01); /* not on 330 */
|
|
|
|
ret |= SETIREGAND(SISSR, 0x3c, 0xfe); /* not on 330 */
|
|
|
|
ret |= SETIREG(SISSR, 0x21, tmp1);
|
|
|
|
ret |= WRITEB(ramptr + 16 + j, j);
|
|
|
|
ret |= READB(ramptr + 16 + j, &tmp1);
|
|
|
|
if (tmp1 == j) {
|
|
|
|
ret |= WRITEB(ramptr + j, j);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_set_rank(struct sisusb_usb_data *sisusb, int *iret,
|
|
|
|
int index, u8 rankno, u8 chab, const u8 dramtype[][5], int bw)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0, ranksize;
|
|
|
|
u8 tmp;
|
|
|
|
|
|
|
|
*iret = 0;
|
|
|
|
|
|
|
|
if ((rankno == 2) && (dramtype[index][0] == 2))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ranksize = dramtype[index][3] / 2 * bw / 32;
|
|
|
|
|
|
|
|
if ((ranksize * rankno) > 128)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
tmp = 0;
|
2016-01-16 01:41:29 +08:00
|
|
|
while ((ranksize >>= 1) > 0)
|
|
|
|
tmp += 0x10;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
tmp |= ((rankno - 1) << 2);
|
|
|
|
tmp |= ((bw / 64) & 0x02);
|
|
|
|
tmp |= (chab & 0x01);
|
|
|
|
|
|
|
|
ret = SETIREG(SISSR, 0x14, tmp);
|
|
|
|
ret |= sisusb_triggersr16(sisusb, 0); /* sic! */
|
|
|
|
|
|
|
|
*iret = 1;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_check_rbc(struct sisusb_usb_data *sisusb, int *iret,
|
|
|
|
u32 inc, int testn)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0, i;
|
|
|
|
u32 j, tmp;
|
|
|
|
|
|
|
|
*iret = 0;
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < testn; i++) {
|
|
|
|
ret |= WRITEL(sisusb->vrambase + j, j);
|
|
|
|
j += inc;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < testn; i++) {
|
|
|
|
ret |= READL(sisusb->vrambase + j, &tmp);
|
2016-01-16 01:41:29 +08:00
|
|
|
if (tmp != j)
|
|
|
|
return ret;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
j += inc;
|
|
|
|
}
|
|
|
|
|
|
|
|
*iret = 1;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_check_ranks(struct sisusb_usb_data *sisusb,
|
|
|
|
int *iret, int rankno, int idx, int bw, const u8 rtype[][5])
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0, i, i2ret;
|
|
|
|
u32 inc;
|
|
|
|
|
|
|
|
*iret = 0;
|
|
|
|
|
|
|
|
for (i = rankno; i >= 1; i--) {
|
2016-01-16 01:41:29 +08:00
|
|
|
inc = 1 << (rtype[idx][2] + rtype[idx][1] + rtype[idx][0] +
|
|
|
|
bw / 64 + i);
|
2005-04-17 06:20:36 +08:00
|
|
|
ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 2);
|
|
|
|
if (!i2ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
inc = 1 << (rtype[idx][2] + bw / 64 + 2);
|
|
|
|
ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 4);
|
|
|
|
if (!i2ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
inc = 1 << (10 + bw / 64);
|
|
|
|
ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 2);
|
|
|
|
if (!i2ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
*iret = 1;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_get_sdram_size(struct sisusb_usb_data *sisusb, int *iret,
|
|
|
|
int bw, int chab)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0, i2ret = 0, i, j;
|
|
|
|
static const u8 sdramtype[13][5] = {
|
|
|
|
{ 2, 12, 9, 64, 0x35 },
|
|
|
|
{ 1, 13, 9, 64, 0x44 },
|
|
|
|
{ 2, 12, 8, 32, 0x31 },
|
|
|
|
{ 2, 11, 9, 32, 0x25 },
|
|
|
|
{ 1, 12, 9, 32, 0x34 },
|
|
|
|
{ 1, 13, 8, 32, 0x40 },
|
|
|
|
{ 2, 11, 8, 16, 0x21 },
|
|
|
|
{ 1, 12, 8, 16, 0x30 },
|
|
|
|
{ 1, 11, 9, 16, 0x24 },
|
|
|
|
{ 1, 11, 8, 8, 0x20 },
|
|
|
|
{ 2, 9, 8, 4, 0x01 },
|
|
|
|
{ 1, 10, 8, 4, 0x10 },
|
|
|
|
{ 1, 9, 8, 2, 0x00 }
|
|
|
|
};
|
|
|
|
|
|
|
|
*iret = 1; /* error */
|
|
|
|
|
|
|
|
for (i = 0; i < 13; i++) {
|
|
|
|
ret |= SETIREGANDOR(SISSR, 0x13, 0x80, sdramtype[i][4]);
|
|
|
|
for (j = 2; j > 0; j--) {
|
2016-01-16 01:41:29 +08:00
|
|
|
ret |= sisusb_set_rank(sisusb, &i2ret, i, j, chab,
|
|
|
|
sdramtype, bw);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!i2ret)
|
|
|
|
continue;
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
ret |= sisusb_check_ranks(sisusb, &i2ret, j, i, bw,
|
|
|
|
sdramtype);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (i2ret) {
|
|
|
|
*iret = 0; /* ram size found */
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_setup_screen(struct sisusb_usb_data *sisusb,
|
|
|
|
int clrall, int drwfr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
u32 address;
|
|
|
|
int i, length, modex, modey, bpp;
|
|
|
|
|
|
|
|
modex = 640; modey = 480; bpp = 2;
|
|
|
|
|
|
|
|
address = sisusb->vrambase; /* Clear video ram */
|
|
|
|
|
|
|
|
if (clrall)
|
|
|
|
length = sisusb->vramsize;
|
|
|
|
else
|
|
|
|
length = modex * bpp * modey;
|
|
|
|
|
|
|
|
ret = sisusb_clear_vram(sisusb, address, length);
|
|
|
|
|
|
|
|
if (!ret && drwfr) {
|
|
|
|
for (i = 0; i < modex; i++) {
|
|
|
|
address = sisusb->vrambase + (i * bpp);
|
|
|
|
ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
|
2016-01-16 01:41:28 +08:00
|
|
|
address, 0xf100);
|
2005-04-17 06:20:36 +08:00
|
|
|
address += (modex * (modey-1) * bpp);
|
|
|
|
ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
|
2016-01-16 01:41:28 +08:00
|
|
|
address, 0xf100);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
for (i = 0; i < modey; i++) {
|
|
|
|
address = sisusb->vrambase + ((i * modex) * bpp);
|
|
|
|
ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
|
2016-01-16 01:41:28 +08:00
|
|
|
address, 0xf100);
|
2005-04-17 06:20:36 +08:00
|
|
|
address += ((modex - 1) * bpp);
|
|
|
|
ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
|
2016-01-16 01:41:28 +08:00
|
|
|
address, 0xf100);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-06-09 11:07:52 +08:00
|
|
|
static void sisusb_set_default_mode(struct sisusb_usb_data *sisusb,
|
2016-01-16 01:41:29 +08:00
|
|
|
int touchengines)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2019-06-09 11:07:52 +08:00
|
|
|
int i, j, modex, bpp, du;
|
2005-04-17 06:20:36 +08:00
|
|
|
u8 sr31, cr63, tmp8;
|
|
|
|
static const char attrdata[] = {
|
2016-01-16 01:41:28 +08:00
|
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
|
|
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
|
|
|
0x01, 0x00, 0x00, 0x00
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
static const char crtcrdata[] = {
|
2016-01-16 01:41:28 +08:00
|
|
|
0x5f, 0x4f, 0x50, 0x82, 0x54, 0x80, 0x0b, 0x3e,
|
|
|
|
0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0xea, 0x8c, 0xdf, 0x28, 0x40, 0xe7, 0x04, 0xa3,
|
2005-04-17 06:20:36 +08:00
|
|
|
0xff
|
|
|
|
};
|
|
|
|
static const char grcdata[] = {
|
2016-01-16 01:41:28 +08:00
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0f,
|
2005-04-17 06:20:36 +08:00
|
|
|
0xff
|
|
|
|
};
|
|
|
|
static const char crtcdata[] = {
|
2016-01-16 01:41:28 +08:00
|
|
|
0x5f, 0x4f, 0x4f, 0x83, 0x55, 0x81, 0x0b, 0x3e,
|
|
|
|
0xe9, 0x8b, 0xdf, 0xe8, 0x0c, 0x00, 0x00, 0x05,
|
2005-04-17 06:20:36 +08:00
|
|
|
0x00
|
|
|
|
};
|
|
|
|
|
2018-07-13 17:55:30 +08:00
|
|
|
modex = 640; bpp = 2;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
GETIREG(SISSR, 0x31, &sr31);
|
|
|
|
GETIREG(SISCR, 0x63, &cr63);
|
|
|
|
SETIREGOR(SISSR, 0x01, 0x20);
|
|
|
|
SETIREG(SISCR, 0x63, cr63 & 0xbf);
|
|
|
|
SETIREGOR(SISCR, 0x17, 0x80);
|
|
|
|
SETIREGOR(SISSR, 0x1f, 0x04);
|
|
|
|
SETIREGAND(SISSR, 0x07, 0xfb);
|
|
|
|
SETIREG(SISSR, 0x00, 0x03); /* seq */
|
|
|
|
SETIREG(SISSR, 0x01, 0x21);
|
|
|
|
SETIREG(SISSR, 0x02, 0x0f);
|
|
|
|
SETIREG(SISSR, 0x03, 0x00);
|
|
|
|
SETIREG(SISSR, 0x04, 0x0e);
|
|
|
|
SETREG(SISMISCW, 0x23); /* misc */
|
|
|
|
for (i = 0; i <= 0x18; i++) { /* crtc */
|
|
|
|
SETIREG(SISCR, i, crtcrdata[i]);
|
|
|
|
}
|
|
|
|
for (i = 0; i <= 0x13; i++) { /* att */
|
|
|
|
GETREG(SISINPSTAT, &tmp8);
|
|
|
|
SETREG(SISAR, i);
|
|
|
|
SETREG(SISAR, attrdata[i]);
|
|
|
|
}
|
|
|
|
GETREG(SISINPSTAT, &tmp8);
|
|
|
|
SETREG(SISAR, 0x14);
|
|
|
|
SETREG(SISAR, 0x00);
|
|
|
|
GETREG(SISINPSTAT, &tmp8);
|
|
|
|
SETREG(SISAR, 0x20);
|
|
|
|
GETREG(SISINPSTAT, &tmp8);
|
|
|
|
for (i = 0; i <= 0x08; i++) { /* grc */
|
|
|
|
SETIREG(SISGR, i, grcdata[i]);
|
|
|
|
}
|
|
|
|
SETIREGAND(SISGR, 0x05, 0xbf);
|
|
|
|
for (i = 0x0A; i <= 0x0E; i++) { /* clr ext */
|
|
|
|
SETIREG(SISSR, i, 0x00);
|
|
|
|
}
|
|
|
|
SETIREGAND(SISSR, 0x37, 0xfe);
|
|
|
|
SETREG(SISMISCW, 0xef); /* sync */
|
|
|
|
SETIREG(SISCR, 0x11, 0x00); /* crtc */
|
2016-01-16 01:41:30 +08:00
|
|
|
for (j = 0x00, i = 0; i <= 7; i++, j++)
|
2005-04-17 06:20:36 +08:00
|
|
|
SETIREG(SISCR, j, crtcdata[i]);
|
2016-01-16 01:41:30 +08:00
|
|
|
|
|
|
|
for (j = 0x10; i <= 10; i++, j++)
|
2005-04-17 06:20:36 +08:00
|
|
|
SETIREG(SISCR, j, crtcdata[i]);
|
2016-01-16 01:41:30 +08:00
|
|
|
|
|
|
|
for (j = 0x15; i <= 12; i++, j++)
|
2005-04-17 06:20:36 +08:00
|
|
|
SETIREG(SISCR, j, crtcdata[i]);
|
2016-01-16 01:41:30 +08:00
|
|
|
|
|
|
|
for (j = 0x0A; i <= 15; i++, j++)
|
2005-04-17 06:20:36 +08:00
|
|
|
SETIREG(SISSR, j, crtcdata[i]);
|
2016-01-16 01:41:30 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
SETIREG(SISSR, 0x0E, (crtcdata[16] & 0xE0));
|
|
|
|
SETIREGANDOR(SISCR, 0x09, 0x5f, ((crtcdata[16] & 0x01) << 5));
|
|
|
|
SETIREG(SISCR, 0x14, 0x4f);
|
|
|
|
du = (modex / 16) * (bpp * 2); /* offset/pitch */
|
|
|
|
SETIREGANDOR(SISSR, 0x0e, 0xf0, ((du >> 8) & 0x0f));
|
|
|
|
SETIREG(SISCR, 0x13, (du & 0xff));
|
|
|
|
du <<= 5;
|
|
|
|
tmp8 = du >> 8;
|
|
|
|
SETIREG(SISSR, 0x10, tmp8);
|
|
|
|
SETIREG(SISSR, 0x31, 0x00); /* VCLK */
|
|
|
|
SETIREG(SISSR, 0x2b, 0x1b);
|
|
|
|
SETIREG(SISSR, 0x2c, 0xe1);
|
|
|
|
SETIREG(SISSR, 0x2d, 0x01);
|
|
|
|
SETIREGAND(SISSR, 0x3d, 0xfe); /* FIFO */
|
|
|
|
SETIREG(SISSR, 0x08, 0xae);
|
|
|
|
SETIREGAND(SISSR, 0x09, 0xf0);
|
|
|
|
SETIREG(SISSR, 0x08, 0x34);
|
|
|
|
SETIREGOR(SISSR, 0x3d, 0x01);
|
|
|
|
SETIREGAND(SISSR, 0x1f, 0x3f); /* mode regs */
|
|
|
|
SETIREGANDOR(SISSR, 0x06, 0xc0, 0x0a);
|
|
|
|
SETIREG(SISCR, 0x19, 0x00);
|
|
|
|
SETIREGAND(SISCR, 0x1a, 0xfc);
|
|
|
|
SETIREGAND(SISSR, 0x0f, 0xb7);
|
|
|
|
SETIREGAND(SISSR, 0x31, 0xfb);
|
|
|
|
SETIREGANDOR(SISSR, 0x21, 0x1f, 0xa0);
|
|
|
|
SETIREGAND(SISSR, 0x32, 0xf3);
|
|
|
|
SETIREGANDOR(SISSR, 0x07, 0xf8, 0x03);
|
|
|
|
SETIREG(SISCR, 0x52, 0x6c);
|
|
|
|
|
|
|
|
SETIREG(SISCR, 0x0d, 0x00); /* adjust frame */
|
|
|
|
SETIREG(SISCR, 0x0c, 0x00);
|
|
|
|
SETIREG(SISSR, 0x0d, 0x00);
|
|
|
|
SETIREGAND(SISSR, 0x37, 0xfe);
|
|
|
|
|
|
|
|
SETIREG(SISCR, 0x32, 0x20);
|
|
|
|
SETIREGAND(SISSR, 0x01, 0xdf); /* enable display */
|
|
|
|
SETIREG(SISCR, 0x63, (cr63 & 0xbf));
|
|
|
|
SETIREG(SISSR, 0x31, (sr31 & 0xfb));
|
|
|
|
|
|
|
|
if (touchengines) {
|
|
|
|
SETIREG(SISSR, 0x20, 0xa1); /* enable engines */
|
|
|
|
SETIREGOR(SISSR, 0x1e, 0x5a);
|
|
|
|
|
|
|
|
SETIREG(SISSR, 0x26, 0x01); /* disable cmdqueue */
|
|
|
|
SETIREG(SISSR, 0x27, 0x1f);
|
|
|
|
SETIREG(SISSR, 0x26, 0x00);
|
|
|
|
}
|
|
|
|
|
2007-08-10 21:34:24 +08:00
|
|
|
SETIREG(SISCR, 0x34, 0x44); /* we just set std mode #44 */
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_init_gfxcore(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0, i, j, bw, chab, iret, retry = 3;
|
|
|
|
u8 tmp8, ramtype;
|
|
|
|
u32 tmp32;
|
|
|
|
static const char mclktable[] = {
|
|
|
|
0x3b, 0x22, 0x01, 143,
|
|
|
|
0x3b, 0x22, 0x01, 143,
|
|
|
|
0x3b, 0x22, 0x01, 143,
|
|
|
|
0x3b, 0x22, 0x01, 143
|
|
|
|
};
|
|
|
|
static const char eclktable[] = {
|
|
|
|
0x3b, 0x22, 0x01, 143,
|
|
|
|
0x3b, 0x22, 0x01, 143,
|
|
|
|
0x3b, 0x22, 0x01, 143,
|
|
|
|
0x3b, 0x22, 0x01, 143
|
|
|
|
};
|
|
|
|
static const char ramtypetable1[] = {
|
|
|
|
0x00, 0x04, 0x60, 0x60,
|
|
|
|
0x0f, 0x0f, 0x1f, 0x1f,
|
|
|
|
0xba, 0xba, 0xba, 0xba,
|
|
|
|
0xa9, 0xa9, 0xac, 0xac,
|
|
|
|
0xa0, 0xa0, 0xa0, 0xa8,
|
|
|
|
0x00, 0x00, 0x02, 0x02,
|
|
|
|
0x30, 0x30, 0x40, 0x40
|
|
|
|
};
|
|
|
|
static const char ramtypetable2[] = {
|
|
|
|
0x77, 0x77, 0x44, 0x44,
|
|
|
|
0x77, 0x77, 0x44, 0x44,
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x5b, 0x5b, 0xab, 0xab,
|
|
|
|
0x00, 0x00, 0xf0, 0xf8
|
|
|
|
};
|
|
|
|
|
|
|
|
while (retry--) {
|
|
|
|
|
|
|
|
/* Enable VGA */
|
|
|
|
ret = GETREG(SISVGAEN, &tmp8);
|
|
|
|
ret |= SETREG(SISVGAEN, (tmp8 | 0x01));
|
|
|
|
|
|
|
|
/* Enable GPU access to VRAM */
|
|
|
|
ret |= GETREG(SISMISCR, &tmp8);
|
|
|
|
ret |= SETREG(SISMISCW, (tmp8 | 0x01));
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
if (ret)
|
|
|
|
continue;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Reset registers */
|
|
|
|
ret |= SETIREGAND(SISCR, 0x5b, 0xdf);
|
|
|
|
ret |= SETIREG(SISSR, 0x05, 0x86);
|
|
|
|
ret |= SETIREGOR(SISSR, 0x20, 0x01);
|
|
|
|
|
|
|
|
ret |= SETREG(SISMISCW, 0x67);
|
|
|
|
|
2016-01-16 01:41:30 +08:00
|
|
|
for (i = 0x06; i <= 0x1f; i++)
|
2005-04-17 06:20:36 +08:00
|
|
|
ret |= SETIREG(SISSR, i, 0x00);
|
2016-01-16 01:41:30 +08:00
|
|
|
|
|
|
|
for (i = 0x21; i <= 0x27; i++)
|
2005-04-17 06:20:36 +08:00
|
|
|
ret |= SETIREG(SISSR, i, 0x00);
|
2016-01-16 01:41:30 +08:00
|
|
|
|
|
|
|
for (i = 0x31; i <= 0x3d; i++)
|
2005-04-17 06:20:36 +08:00
|
|
|
ret |= SETIREG(SISSR, i, 0x00);
|
2016-01-16 01:41:30 +08:00
|
|
|
|
|
|
|
for (i = 0x12; i <= 0x1b; i++)
|
2005-04-17 06:20:36 +08:00
|
|
|
ret |= SETIREG(SISSR, i, 0x00);
|
2016-01-16 01:41:30 +08:00
|
|
|
|
|
|
|
for (i = 0x79; i <= 0x7c; i++)
|
2005-04-17 06:20:36 +08:00
|
|
|
ret |= SETIREG(SISCR, i, 0x00);
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
if (ret)
|
|
|
|
continue;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret |= SETIREG(SISCR, 0x63, 0x80);
|
|
|
|
|
|
|
|
ret |= GETIREG(SISSR, 0x3a, &ramtype);
|
|
|
|
ramtype &= 0x03;
|
|
|
|
|
|
|
|
ret |= SETIREG(SISSR, 0x28, mclktable[ramtype * 4]);
|
|
|
|
ret |= SETIREG(SISSR, 0x29, mclktable[(ramtype * 4) + 1]);
|
|
|
|
ret |= SETIREG(SISSR, 0x2a, mclktable[(ramtype * 4) + 2]);
|
|
|
|
|
|
|
|
ret |= SETIREG(SISSR, 0x2e, eclktable[ramtype * 4]);
|
|
|
|
ret |= SETIREG(SISSR, 0x2f, eclktable[(ramtype * 4) + 1]);
|
|
|
|
ret |= SETIREG(SISSR, 0x30, eclktable[(ramtype * 4) + 2]);
|
|
|
|
|
|
|
|
ret |= SETIREG(SISSR, 0x07, 0x18);
|
|
|
|
ret |= SETIREG(SISSR, 0x11, 0x0f);
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
if (ret)
|
|
|
|
continue;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
for (i = 0x15, j = 0; i <= 0x1b; i++, j++) {
|
2016-01-16 01:41:29 +08:00
|
|
|
ret |= SETIREG(SISSR, i,
|
|
|
|
ramtypetable1[(j*4) + ramtype]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
for (i = 0x40, j = 0; i <= 0x44; i++, j++) {
|
2016-01-16 01:41:29 +08:00
|
|
|
ret |= SETIREG(SISCR, i,
|
|
|
|
ramtypetable2[(j*4) + ramtype]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ret |= SETIREG(SISCR, 0x49, 0xaa);
|
|
|
|
|
|
|
|
ret |= SETIREG(SISSR, 0x1f, 0x00);
|
|
|
|
ret |= SETIREG(SISSR, 0x20, 0xa0);
|
|
|
|
ret |= SETIREG(SISSR, 0x23, 0xf6);
|
|
|
|
ret |= SETIREG(SISSR, 0x24, 0x0d);
|
|
|
|
ret |= SETIREG(SISSR, 0x25, 0x33);
|
|
|
|
|
|
|
|
ret |= SETIREG(SISSR, 0x11, 0x0f);
|
|
|
|
|
|
|
|
ret |= SETIREGOR(SISPART1, 0x2f, 0x01);
|
|
|
|
|
|
|
|
ret |= SETIREGAND(SISCAP, 0x3f, 0xef);
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
if (ret)
|
|
|
|
continue;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret |= SETIREG(SISPART1, 0x00, 0x00);
|
|
|
|
|
|
|
|
ret |= GETIREG(SISSR, 0x13, &tmp8);
|
|
|
|
tmp8 >>= 4;
|
|
|
|
|
|
|
|
ret |= SETIREG(SISPART1, 0x02, 0x00);
|
|
|
|
ret |= SETIREG(SISPART1, 0x2e, 0x08);
|
|
|
|
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x50, &tmp32);
|
|
|
|
tmp32 &= 0x00f00000;
|
|
|
|
tmp8 = (tmp32 == 0x100000) ? 0x33 : 0x03;
|
|
|
|
ret |= SETIREG(SISSR, 0x25, tmp8);
|
|
|
|
tmp8 = (tmp32 == 0x100000) ? 0xaa : 0x88;
|
|
|
|
ret |= SETIREG(SISCR, 0x49, tmp8);
|
|
|
|
|
|
|
|
ret |= SETIREG(SISSR, 0x27, 0x1f);
|
|
|
|
ret |= SETIREG(SISSR, 0x31, 0x00);
|
|
|
|
ret |= SETIREG(SISSR, 0x32, 0x11);
|
|
|
|
ret |= SETIREG(SISSR, 0x33, 0x00);
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
if (ret)
|
|
|
|
continue;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret |= SETIREG(SISCR, 0x83, 0x00);
|
|
|
|
|
2019-06-09 11:07:52 +08:00
|
|
|
sisusb_set_default_mode(sisusb, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret |= SETIREGAND(SISSR, 0x21, 0xdf);
|
|
|
|
ret |= SETIREGOR(SISSR, 0x01, 0x20);
|
|
|
|
ret |= SETIREGOR(SISSR, 0x16, 0x0f);
|
|
|
|
|
|
|
|
ret |= sisusb_triggersr16(sisusb, ramtype);
|
|
|
|
|
|
|
|
/* Disable refresh */
|
|
|
|
ret |= SETIREGAND(SISSR, 0x17, 0xf8);
|
|
|
|
ret |= SETIREGOR(SISSR, 0x19, 0x03);
|
|
|
|
|
|
|
|
ret |= sisusb_getbuswidth(sisusb, &bw, &chab);
|
|
|
|
ret |= sisusb_verify_mclk(sisusb);
|
|
|
|
|
|
|
|
if (ramtype <= 1) {
|
|
|
|
ret |= sisusb_get_sdram_size(sisusb, &iret, bw, chab);
|
|
|
|
if (iret) {
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_err(&sisusb->sisusb_dev->dev,
|
|
|
|
"RAM size detection failed, assuming 8MB video RAM\n");
|
2016-01-16 01:41:28 +08:00
|
|
|
ret |= SETIREG(SISSR, 0x14, 0x31);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* TODO */
|
|
|
|
}
|
|
|
|
} else {
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_err(&sisusb->sisusb_dev->dev,
|
|
|
|
"DDR RAM device found, assuming 8MB video RAM\n");
|
2016-01-16 01:41:28 +08:00
|
|
|
ret |= SETIREG(SISSR, 0x14, 0x31);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* *** TODO *** */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable refresh */
|
|
|
|
ret |= SETIREG(SISSR, 0x16, ramtypetable1[4 + ramtype]);
|
|
|
|
ret |= SETIREG(SISSR, 0x17, ramtypetable1[8 + ramtype]);
|
|
|
|
ret |= SETIREG(SISSR, 0x19, ramtypetable1[16 + ramtype]);
|
|
|
|
|
|
|
|
ret |= SETIREGOR(SISSR, 0x21, 0x20);
|
|
|
|
|
|
|
|
ret |= SETIREG(SISSR, 0x22, 0xfb);
|
|
|
|
ret |= SETIREG(SISSR, 0x21, 0xa5);
|
|
|
|
|
|
|
|
if (ret == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef SETREG
|
|
|
|
#undef GETREG
|
|
|
|
#undef SETIREG
|
|
|
|
#undef GETIREG
|
|
|
|
#undef SETIREGOR
|
|
|
|
#undef SETIREGAND
|
|
|
|
#undef SETIREGANDOR
|
|
|
|
#undef READL
|
|
|
|
#undef WRITEL
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static void sisusb_get_ramconfig(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
u8 tmp8, tmp82, ramtype;
|
|
|
|
int bw = 0;
|
|
|
|
char *ramtypetext1 = NULL;
|
2014-02-25 02:01:16 +08:00
|
|
|
static const char ram_datarate[4] = {'S', 'S', 'D', 'D'};
|
|
|
|
static const char ram_dynamictype[4] = {'D', 'G', 'D', 'G'};
|
2005-04-17 06:20:36 +08:00
|
|
|
static const int busSDR[4] = {64, 64, 128, 128};
|
|
|
|
static const int busDDR[4] = {32, 32, 64, 64};
|
2016-01-16 01:41:28 +08:00
|
|
|
static const int busDDRA[4] = {64+32, 64+32, (64+32)*2, (64+32)*2};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
sisusb_getidxreg(sisusb, SISSR, 0x14, &tmp8);
|
|
|
|
sisusb_getidxreg(sisusb, SISSR, 0x15, &tmp82);
|
|
|
|
sisusb_getidxreg(sisusb, SISSR, 0x3a, &ramtype);
|
|
|
|
sisusb->vramsize = (1 << ((tmp8 & 0xf0) >> 4)) * 1024 * 1024;
|
|
|
|
ramtype &= 0x03;
|
|
|
|
switch ((tmp8 >> 2) & 0x03) {
|
2016-01-16 01:41:29 +08:00
|
|
|
case 0:
|
|
|
|
ramtypetext1 = "1 ch/1 r";
|
2016-01-16 01:41:30 +08:00
|
|
|
if (tmp82 & 0x10)
|
2005-04-17 06:20:36 +08:00
|
|
|
bw = 32;
|
2016-01-16 01:41:30 +08:00
|
|
|
else
|
2005-04-17 06:20:36 +08:00
|
|
|
bw = busSDR[(tmp8 & 0x03)];
|
2016-01-16 01:41:30 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2016-01-16 01:41:29 +08:00
|
|
|
case 1:
|
|
|
|
ramtypetext1 = "1 ch/2 r";
|
2005-04-17 06:20:36 +08:00
|
|
|
sisusb->vramsize <<= 1;
|
|
|
|
bw = busSDR[(tmp8 & 0x03)];
|
|
|
|
break;
|
2016-01-16 01:41:29 +08:00
|
|
|
case 2:
|
2018-04-28 03:12:31 +08:00
|
|
|
ramtypetext1 = "asymmetric";
|
2005-04-17 06:20:36 +08:00
|
|
|
sisusb->vramsize += sisusb->vramsize/2;
|
|
|
|
bw = busDDRA[(tmp8 & 0x03)];
|
|
|
|
break;
|
2016-01-16 01:41:29 +08:00
|
|
|
case 3:
|
|
|
|
ramtypetext1 = "2 channel";
|
2005-04-17 06:20:36 +08:00
|
|
|
sisusb->vramsize <<= 1;
|
|
|
|
bw = busDDR[(tmp8 & 0x03)];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_info(&sisusb->sisusb_dev->dev,
|
|
|
|
"%dMB %s %cDR S%cRAM, bus width %d\n",
|
|
|
|
sisusb->vramsize >> 20, ramtypetext1,
|
|
|
|
ram_datarate[ramtype], ram_dynamictype[ramtype], bw);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_do_init_gfxdevice(struct sisusb_usb_data *sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_packet packet;
|
|
|
|
int ret;
|
|
|
|
u32 tmp32;
|
|
|
|
|
|
|
|
/* Do some magic */
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x00000324;
|
|
|
|
packet.data = 0x00000004;
|
|
|
|
ret = sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
|
|
|
|
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x00000364;
|
|
|
|
packet.data = 0x00000004;
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
|
|
|
|
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x00000384;
|
|
|
|
packet.data = 0x00000004;
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
|
|
|
|
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x00000100;
|
|
|
|
packet.data = 0x00000700;
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
|
|
|
|
|
|
|
|
packet.header = 0x000f;
|
|
|
|
packet.address = 0x00000004;
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 6, &packet, 0);
|
|
|
|
packet.data |= 0x17;
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
|
|
|
|
|
|
|
|
/* Init BAR 0 (VRAM) */
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
|
|
|
|
ret |= sisusb_write_pci_config(sisusb, 0x10, 0xfffffff0);
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
|
|
|
|
tmp32 &= 0x0f;
|
|
|
|
tmp32 |= SISUSB_PCI_MEMBASE;
|
|
|
|
ret |= sisusb_write_pci_config(sisusb, 0x10, tmp32);
|
|
|
|
|
|
|
|
/* Init BAR 1 (MMIO) */
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
|
|
|
|
ret |= sisusb_write_pci_config(sisusb, 0x14, 0xfffffff0);
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
|
|
|
|
tmp32 &= 0x0f;
|
|
|
|
tmp32 |= SISUSB_PCI_MMIOBASE;
|
|
|
|
ret |= sisusb_write_pci_config(sisusb, 0x14, tmp32);
|
|
|
|
|
|
|
|
/* Init BAR 2 (i/o ports) */
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
|
|
|
|
ret |= sisusb_write_pci_config(sisusb, 0x18, 0xfffffff0);
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
|
|
|
|
tmp32 &= 0x0f;
|
|
|
|
tmp32 |= SISUSB_PCI_IOPORTBASE;
|
|
|
|
ret |= sisusb_write_pci_config(sisusb, 0x18, tmp32);
|
|
|
|
|
|
|
|
/* Enable memory and i/o access */
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x04, &tmp32);
|
|
|
|
tmp32 |= 0x3;
|
|
|
|
ret |= sisusb_write_pci_config(sisusb, 0x04, tmp32);
|
|
|
|
|
|
|
|
if (ret == 0) {
|
|
|
|
/* Some further magic */
|
|
|
|
packet.header = 0x001f;
|
|
|
|
packet.address = 0x00000050;
|
|
|
|
packet.data = 0x000000ff;
|
|
|
|
ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the graphics device (return 0 on success)
|
|
|
|
* This initializes the net2280 as well as the PCI registers
|
|
|
|
* of the graphics board.
|
|
|
|
*/
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_init_gfxdevice(struct sisusb_usb_data *sisusb, int initscreen)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ret = 0, test = 0;
|
|
|
|
u32 tmp32;
|
|
|
|
|
|
|
|
if (sisusb->devinit == 1) {
|
|
|
|
/* Read PCI BARs and see if they have been set up */
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
|
2016-01-16 01:41:29 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if ((tmp32 & 0xfffffff0) == SISUSB_PCI_MEMBASE)
|
|
|
|
test++;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
|
2016-01-16 01:41:29 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if ((tmp32 & 0xfffffff0) == SISUSB_PCI_MMIOBASE)
|
|
|
|
test++;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
|
2016-01-16 01:41:29 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if ((tmp32 & 0xfffffff0) == SISUSB_PCI_IOPORTBASE)
|
|
|
|
test++;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* No? So reset the device */
|
|
|
|
if ((sisusb->devinit == 0) || (test != 3)) {
|
|
|
|
|
|
|
|
ret |= sisusb_do_init_gfxdevice(sisusb);
|
|
|
|
|
|
|
|
if (ret == 0)
|
|
|
|
sisusb->devinit = 1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sisusb->devinit) {
|
|
|
|
/* Initialize the graphics core */
|
|
|
|
if (sisusb_init_gfxcore(sisusb) == 0) {
|
|
|
|
sisusb->gfxinit = 1;
|
|
|
|
sisusb_get_ramconfig(sisusb);
|
2019-06-09 11:07:52 +08:00
|
|
|
sisusb_set_default_mode(sisusb, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
ret |= sisusb_setup_screen(sisusb, 1, initscreen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fops */
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_open(struct inode *inode, struct file *file)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
struct usb_interface *interface;
|
|
|
|
int subminor = iminor(inode);
|
|
|
|
|
2015-04-30 17:33:02 +08:00
|
|
|
interface = usb_find_interface(&sisusb_driver, subminor);
|
2016-01-16 01:41:30 +08:00
|
|
|
if (!interface)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2015-04-30 17:33:02 +08:00
|
|
|
sisusb = usb_get_intfdata(interface);
|
2016-01-16 01:41:30 +08:00
|
|
|
if (!sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_lock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!sisusb->present || !sisusb->ready) {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sisusb->isopen) {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!sisusb->devinit) {
|
2010-07-16 23:36:26 +08:00
|
|
|
if (sisusb->sisusb_dev->speed == USB_SPEED_HIGH ||
|
2016-05-02 19:09:30 +08:00
|
|
|
sisusb->sisusb_dev->speed >= USB_SPEED_SUPER) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (sisusb_init_gfxdevice(sisusb, 0)) {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_err(&sisusb->sisusb_dev->dev,
|
|
|
|
"Failed to initialize device\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
} else {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_err(&sisusb->sisusb_dev->dev,
|
|
|
|
"Device not attached to USB 2.0 hub\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-29 23:01:16 +08:00
|
|
|
/* Increment usage count for our sisusb */
|
2005-04-17 06:20:36 +08:00
|
|
|
kref_get(&sisusb->kref);
|
|
|
|
|
|
|
|
sisusb->isopen = 1;
|
|
|
|
|
|
|
|
file->private_data = sisusb;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-12-08 17:07:46 +08:00
|
|
|
static void sisusb_delete(struct kref *kref)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb = to_sisusb_dev(kref);
|
|
|
|
|
|
|
|
if (!sisusb)
|
|
|
|
return;
|
|
|
|
|
2014-11-21 22:50:44 +08:00
|
|
|
usb_put_dev(sisusb->sisusb_dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
sisusb->sisusb_dev = NULL;
|
|
|
|
sisusb_free_buffers(sisusb);
|
|
|
|
sisusb_free_urbs(sisusb);
|
|
|
|
kfree(sisusb);
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_release(struct inode *inode, struct file *file)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
|
2015-04-30 17:33:02 +08:00
|
|
|
sisusb = file->private_data;
|
|
|
|
if (!sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_lock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (sisusb->present) {
|
|
|
|
/* Wait for all URBs to finish if device still present */
|
|
|
|
if (!sisusb_wait_all_out_complete(sisusb))
|
|
|
|
sisusb_kill_all_busy(sisusb);
|
|
|
|
}
|
|
|
|
|
|
|
|
sisusb->isopen = 0;
|
|
|
|
file->private_data = NULL;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* decrement the usage count on our device */
|
|
|
|
kref_put(&sisusb->kref, sisusb_delete);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static ssize_t sisusb_read(struct file *file, char __user *buffer,
|
|
|
|
size_t count, loff_t *ppos)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
ssize_t bytes_read = 0;
|
|
|
|
int errno = 0;
|
|
|
|
u8 buf8;
|
|
|
|
u16 buf16;
|
|
|
|
u32 buf32, address;
|
|
|
|
|
2015-04-30 17:33:02 +08:00
|
|
|
sisusb = file->private_data;
|
|
|
|
if (!sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_lock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((*ppos) >= SISUSB_PCI_PSEUDO_IOPORTBASE &&
|
2016-01-16 01:41:28 +08:00
|
|
|
(*ppos) < SISUSB_PCI_PSEUDO_IOPORTBASE + 128) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
address = (*ppos) - SISUSB_PCI_PSEUDO_IOPORTBASE +
|
|
|
|
SISUSB_PCI_IOPORTBASE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Read i/o ports
|
|
|
|
* Byte, word and long(32) can be read. As this
|
|
|
|
* emulates inX instructions, the data returned is
|
|
|
|
* in machine-endianness.
|
|
|
|
*/
|
|
|
|
switch (count) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case 1:
|
2016-01-16 01:41:29 +08:00
|
|
|
if (sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO,
|
2016-01-16 01:41:28 +08:00
|
|
|
address, &buf8))
|
|
|
|
errno = -EIO;
|
|
|
|
else if (put_user(buf8, (u8 __user *)buffer))
|
|
|
|
errno = -EFAULT;
|
|
|
|
else
|
|
|
|
bytes_read = 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case 2:
|
2016-01-16 01:41:29 +08:00
|
|
|
if (sisusb_read_memio_word(sisusb, SISUSB_TYPE_IO,
|
2016-01-16 01:41:28 +08:00
|
|
|
address, &buf16))
|
|
|
|
errno = -EIO;
|
|
|
|
else if (put_user(buf16, (u16 __user *)buffer))
|
|
|
|
errno = -EFAULT;
|
|
|
|
else
|
|
|
|
bytes_read = 2;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case 4:
|
2016-01-16 01:41:29 +08:00
|
|
|
if (sisusb_read_memio_long(sisusb, SISUSB_TYPE_IO,
|
2016-01-16 01:41:28 +08:00
|
|
|
address, &buf32))
|
|
|
|
errno = -EIO;
|
|
|
|
else if (put_user(buf32, (u32 __user *)buffer))
|
|
|
|
errno = -EFAULT;
|
|
|
|
else
|
|
|
|
bytes_read = 4;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
default:
|
|
|
|
errno = -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
} else if ((*ppos) >= SISUSB_PCI_PSEUDO_MEMBASE && (*ppos) <
|
|
|
|
SISUSB_PCI_PSEUDO_MEMBASE + sisusb->vramsize) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
address = (*ppos) - SISUSB_PCI_PSEUDO_MEMBASE +
|
|
|
|
SISUSB_PCI_MEMBASE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Read video ram
|
|
|
|
* Remember: Data delivered is never endian-corrected
|
|
|
|
*/
|
|
|
|
errno = sisusb_read_mem_bulk(sisusb, address,
|
2016-01-16 01:41:28 +08:00
|
|
|
NULL, count, buffer, &bytes_read);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (bytes_read)
|
|
|
|
errno = bytes_read;
|
|
|
|
|
|
|
|
} else if ((*ppos) >= SISUSB_PCI_PSEUDO_MMIOBASE &&
|
2016-01-16 01:41:29 +08:00
|
|
|
(*ppos) < SISUSB_PCI_PSEUDO_MMIOBASE +
|
|
|
|
SISUSB_PCI_MMIOSIZE) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
address = (*ppos) - SISUSB_PCI_PSEUDO_MMIOBASE +
|
|
|
|
SISUSB_PCI_MMIOBASE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Read MMIO
|
|
|
|
* Remember: Data delivered is never endian-corrected
|
|
|
|
*/
|
|
|
|
errno = sisusb_read_mem_bulk(sisusb, address,
|
2016-01-16 01:41:28 +08:00
|
|
|
NULL, count, buffer, &bytes_read);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (bytes_read)
|
|
|
|
errno = bytes_read;
|
|
|
|
|
|
|
|
} else if ((*ppos) >= SISUSB_PCI_PSEUDO_PCIBASE &&
|
2016-01-16 01:41:28 +08:00
|
|
|
(*ppos) <= SISUSB_PCI_PSEUDO_PCIBASE + 0x5c) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (count != 4) {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
address = (*ppos) - SISUSB_PCI_PSEUDO_PCIBASE;
|
|
|
|
|
|
|
|
/* Read PCI config register
|
|
|
|
* Return value delivered in machine endianness.
|
|
|
|
*/
|
|
|
|
if (sisusb_read_pci_config(sisusb, address, &buf32))
|
|
|
|
errno = -EIO;
|
|
|
|
else if (put_user(buf32, (u32 __user *)buffer))
|
|
|
|
errno = -EFAULT;
|
|
|
|
else
|
|
|
|
bytes_read = 4;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
errno = -EBADFD;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
(*ppos) += bytes_read;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return errno ? errno : bytes_read;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static ssize_t sisusb_write(struct file *file, const char __user *buffer,
|
|
|
|
size_t count, loff_t *ppos)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
int errno = 0;
|
|
|
|
ssize_t bytes_written = 0;
|
|
|
|
u8 buf8;
|
|
|
|
u16 buf16;
|
|
|
|
u32 buf32, address;
|
|
|
|
|
2015-04-30 17:33:02 +08:00
|
|
|
sisusb = file->private_data;
|
|
|
|
if (!sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_lock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((*ppos) >= SISUSB_PCI_PSEUDO_IOPORTBASE &&
|
2016-01-16 01:41:28 +08:00
|
|
|
(*ppos) < SISUSB_PCI_PSEUDO_IOPORTBASE + 128) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
address = (*ppos) - SISUSB_PCI_PSEUDO_IOPORTBASE +
|
|
|
|
SISUSB_PCI_IOPORTBASE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Write i/o ports
|
|
|
|
* Byte, word and long(32) can be written. As this
|
|
|
|
* emulates outX instructions, the data is expected
|
|
|
|
* in machine-endianness.
|
|
|
|
*/
|
|
|
|
switch (count) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case 1:
|
|
|
|
if (get_user(buf8, (u8 __user *)buffer))
|
|
|
|
errno = -EFAULT;
|
|
|
|
else if (sisusb_write_memio_byte(sisusb,
|
2016-01-16 01:41:29 +08:00
|
|
|
SISUSB_TYPE_IO, address, buf8))
|
2016-01-16 01:41:28 +08:00
|
|
|
errno = -EIO;
|
|
|
|
else
|
|
|
|
bytes_written = 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case 2:
|
|
|
|
if (get_user(buf16, (u16 __user *)buffer))
|
|
|
|
errno = -EFAULT;
|
|
|
|
else if (sisusb_write_memio_word(sisusb,
|
2016-01-16 01:41:29 +08:00
|
|
|
SISUSB_TYPE_IO, address, buf16))
|
2016-01-16 01:41:28 +08:00
|
|
|
errno = -EIO;
|
|
|
|
else
|
|
|
|
bytes_written = 2;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case 4:
|
|
|
|
if (get_user(buf32, (u32 __user *)buffer))
|
|
|
|
errno = -EFAULT;
|
|
|
|
else if (sisusb_write_memio_long(sisusb,
|
2016-01-16 01:41:29 +08:00
|
|
|
SISUSB_TYPE_IO, address, buf32))
|
2016-01-16 01:41:28 +08:00
|
|
|
errno = -EIO;
|
|
|
|
else
|
|
|
|
bytes_written = 4;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
default:
|
|
|
|
errno = -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
} else if ((*ppos) >= SISUSB_PCI_PSEUDO_MEMBASE &&
|
2016-01-16 01:41:29 +08:00
|
|
|
(*ppos) < SISUSB_PCI_PSEUDO_MEMBASE +
|
|
|
|
sisusb->vramsize) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
address = (*ppos) - SISUSB_PCI_PSEUDO_MEMBASE +
|
|
|
|
SISUSB_PCI_MEMBASE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Write video ram.
|
|
|
|
* Buffer is copied 1:1, therefore, on big-endian
|
|
|
|
* machines, the data must be swapped by userland
|
|
|
|
* in advance (if applicable; no swapping in 8bpp
|
|
|
|
* mode or if YUV data is being transferred).
|
|
|
|
*/
|
|
|
|
errno = sisusb_write_mem_bulk(sisusb, address, NULL,
|
2016-01-16 01:41:28 +08:00
|
|
|
count, buffer, 0, &bytes_written);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (bytes_written)
|
|
|
|
errno = bytes_written;
|
|
|
|
|
|
|
|
} else if ((*ppos) >= SISUSB_PCI_PSEUDO_MMIOBASE &&
|
2016-01-16 01:41:29 +08:00
|
|
|
(*ppos) < SISUSB_PCI_PSEUDO_MMIOBASE +
|
|
|
|
SISUSB_PCI_MMIOSIZE) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
address = (*ppos) - SISUSB_PCI_PSEUDO_MMIOBASE +
|
|
|
|
SISUSB_PCI_MMIOBASE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Write MMIO.
|
|
|
|
* Buffer is copied 1:1, therefore, on big-endian
|
|
|
|
* machines, the data must be swapped by userland
|
|
|
|
* in advance.
|
|
|
|
*/
|
|
|
|
errno = sisusb_write_mem_bulk(sisusb, address, NULL,
|
2016-01-16 01:41:28 +08:00
|
|
|
count, buffer, 0, &bytes_written);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (bytes_written)
|
|
|
|
errno = bytes_written;
|
|
|
|
|
|
|
|
} else if ((*ppos) >= SISUSB_PCI_PSEUDO_PCIBASE &&
|
2016-01-16 01:41:29 +08:00
|
|
|
(*ppos) <= SISUSB_PCI_PSEUDO_PCIBASE +
|
|
|
|
SISUSB_PCI_PCONFSIZE) {
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (count != 4) {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
address = (*ppos) - SISUSB_PCI_PSEUDO_PCIBASE;
|
|
|
|
|
|
|
|
/* Write PCI config register.
|
|
|
|
* Given value expected in machine endianness.
|
|
|
|
*/
|
|
|
|
if (get_user(buf32, (u32 __user *)buffer))
|
|
|
|
errno = -EFAULT;
|
|
|
|
else if (sisusb_write_pci_config(sisusb, address, buf32))
|
|
|
|
errno = -EIO;
|
|
|
|
else
|
|
|
|
bytes_written = 4;
|
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* Error */
|
|
|
|
errno = -EBADFD;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
(*ppos) += bytes_written;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return errno ? errno : bytes_written;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static loff_t sisusb_lseek(struct file *file, loff_t offset, int orig)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
loff_t ret;
|
|
|
|
|
2015-04-30 17:33:02 +08:00
|
|
|
sisusb = file->private_data;
|
|
|
|
if (!sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_lock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2015-12-06 11:04:48 +08:00
|
|
|
ret = no_seek_end_llseek(file, offset, orig);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static int sisusb_handle_command(struct sisusb_usb_data *sisusb,
|
|
|
|
struct sisusb_command *y, unsigned long arg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2020-04-21 11:41:25 +08:00
|
|
|
int retval, length;
|
|
|
|
u32 port, address;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-29 23:01:16 +08:00
|
|
|
/* All our commands require the device
|
|
|
|
* to be initialized.
|
|
|
|
*/
|
|
|
|
if (!sisusb->devinit)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
port = y->data3 -
|
|
|
|
SISUSB_PCI_PSEUDO_IOPORTBASE +
|
|
|
|
SISUSB_PCI_IOPORTBASE;
|
|
|
|
|
|
|
|
switch (y->operation) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case SUCMD_GET:
|
|
|
|
retval = sisusb_getidxreg(sisusb, port, y->data0, &y->data1);
|
|
|
|
if (!retval) {
|
|
|
|
if (copy_to_user((void __user *)arg, y, sizeof(*y)))
|
|
|
|
retval = -EFAULT;
|
|
|
|
}
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SUCMD_SET:
|
|
|
|
retval = sisusb_setidxreg(sisusb, port, y->data0, y->data1);
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SUCMD_SETOR:
|
|
|
|
retval = sisusb_setidxregor(sisusb, port, y->data0, y->data1);
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SUCMD_SETAND:
|
|
|
|
retval = sisusb_setidxregand(sisusb, port, y->data0, y->data1);
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SUCMD_SETANDOR:
|
|
|
|
retval = sisusb_setidxregandor(sisusb, port, y->data0,
|
|
|
|
y->data1, y->data2);
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SUCMD_SETMASK:
|
|
|
|
retval = sisusb_setidxregmask(sisusb, port, y->data0,
|
|
|
|
y->data1, y->data2);
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SUCMD_CLRSCR:
|
|
|
|
/* Gfx core must be initialized */
|
|
|
|
if (!sisusb->gfxinit)
|
|
|
|
return -ENODEV;
|
2005-08-29 23:01:16 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
length = (y->data0 << 16) | (y->data1 << 8) | y->data2;
|
|
|
|
address = y->data3 - SISUSB_PCI_PSEUDO_MEMBASE +
|
2005-04-17 06:20:36 +08:00
|
|
|
SISUSB_PCI_MEMBASE;
|
2016-01-16 01:41:28 +08:00
|
|
|
retval = sisusb_clear_vram(sisusb, address, length);
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SUCMD_HANDLETEXTMODE:
|
|
|
|
retval = 0;
|
|
|
|
break;
|
2005-08-29 23:01:16 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
default:
|
|
|
|
retval = -EINVAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-08-29 23:01:16 +08:00
|
|
|
if (retval > 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = -EIO;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
static long sisusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
struct sisusb_info x;
|
|
|
|
struct sisusb_command y;
|
2010-03-01 21:10:56 +08:00
|
|
|
long retval = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
u32 __user *argp = (u32 __user *)arg;
|
|
|
|
|
2015-04-30 17:33:02 +08:00
|
|
|
sisusb = file->private_data;
|
|
|
|
if (!sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_lock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
|
|
|
|
retval = -ENODEV;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (cmd) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case SISUSB_GET_CONFIG_SIZE:
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
if (put_user(sizeof(x), argp))
|
|
|
|
retval = -EFAULT;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SISUSB_GET_CONFIG:
|
|
|
|
|
|
|
|
x.sisusb_id = SISUSB_ID;
|
|
|
|
x.sisusb_version = SISUSB_VERSION;
|
|
|
|
x.sisusb_revision = SISUSB_REVISION;
|
|
|
|
x.sisusb_patchlevel = SISUSB_PATCHLEVEL;
|
|
|
|
x.sisusb_gfxinit = sisusb->gfxinit;
|
|
|
|
x.sisusb_vrambase = SISUSB_PCI_PSEUDO_MEMBASE;
|
|
|
|
x.sisusb_mmiobase = SISUSB_PCI_PSEUDO_MMIOBASE;
|
|
|
|
x.sisusb_iobase = SISUSB_PCI_PSEUDO_IOPORTBASE;
|
|
|
|
x.sisusb_pcibase = SISUSB_PCI_PSEUDO_PCIBASE;
|
|
|
|
x.sisusb_vramsize = sisusb->vramsize;
|
|
|
|
x.sisusb_minor = sisusb->minor;
|
|
|
|
x.sisusb_fbdevactive = 0;
|
|
|
|
x.sisusb_conactive = 0;
|
|
|
|
memset(x.sisusb_reserved, 0, sizeof(x.sisusb_reserved));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
if (copy_to_user((void __user *)arg, &x, sizeof(x)))
|
|
|
|
retval = -EFAULT;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
case SISUSB_COMMAND:
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
if (copy_from_user(&y, (void __user *)arg, sizeof(y)))
|
|
|
|
retval = -EFAULT;
|
|
|
|
else
|
|
|
|
retval = sisusb_handle_command(sisusb, &y, arg);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
default:
|
|
|
|
retval = -ENOTTY;
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
err_out:
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2019-01-22 23:12:00 +08:00
|
|
|
#ifdef CONFIG_COMPAT
|
2016-01-16 01:41:29 +08:00
|
|
|
static long sisusb_compat_ioctl(struct file *f, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
switch (cmd) {
|
2016-01-16 01:41:28 +08:00
|
|
|
case SISUSB_GET_CONFIG_SIZE:
|
|
|
|
case SISUSB_GET_CONFIG:
|
|
|
|
case SISUSB_COMMAND:
|
2017-07-10 11:31:31 +08:00
|
|
|
return sisusb_ioctl(f, cmd, arg);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-08-06 07:37:11 +08:00
|
|
|
static const struct file_operations usb_sisusb_fops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = sisusb_open,
|
|
|
|
.release = sisusb_release,
|
|
|
|
.read = sisusb_read,
|
|
|
|
.write = sisusb_write,
|
2007-08-10 21:34:24 +08:00
|
|
|
.llseek = sisusb_lseek,
|
2019-01-22 23:12:00 +08:00
|
|
|
#ifdef CONFIG_COMPAT
|
2005-04-17 06:20:36 +08:00
|
|
|
.compat_ioctl = sisusb_compat_ioctl,
|
|
|
|
#endif
|
2008-05-23 05:48:48 +08:00
|
|
|
.unlocked_ioctl = sisusb_ioctl
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_class_driver usb_sisusb_class = {
|
2005-08-29 23:01:16 +08:00
|
|
|
.name = "sisusbvga%d",
|
|
|
|
.fops = &usb_sisusb_fops,
|
2005-04-17 06:20:36 +08:00
|
|
|
.minor_base = SISUSB_MINOR
|
|
|
|
};
|
|
|
|
|
|
|
|
static int sisusb_probe(struct usb_interface *intf,
|
2016-01-16 01:41:28 +08:00
|
|
|
const struct usb_device_id *id)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
int retval = 0, i;
|
2023-04-11 03:38:22 +08:00
|
|
|
static const u8 ep_addresses[] = {
|
|
|
|
SISUSB_EP_GFX_IN | USB_DIR_IN,
|
|
|
|
SISUSB_EP_GFX_OUT | USB_DIR_OUT,
|
|
|
|
SISUSB_EP_GFX_BULK_OUT | USB_DIR_OUT,
|
|
|
|
SISUSB_EP_GFX_LBULK_OUT | USB_DIR_OUT,
|
|
|
|
SISUSB_EP_BRIDGE_IN | USB_DIR_IN,
|
|
|
|
SISUSB_EP_BRIDGE_OUT | USB_DIR_OUT,
|
|
|
|
0};
|
|
|
|
|
|
|
|
/* Are the expected endpoints present? */
|
|
|
|
if (!usb_check_bulk_endpoints(intf, ep_addresses)) {
|
|
|
|
dev_err(&intf->dev, "Invalid USB2VGA device\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-08-15 22:38:12 +08:00
|
|
|
dev_info(&dev->dev, "USB2VGA dongle found at address %d\n",
|
2016-01-16 01:41:28 +08:00
|
|
|
dev->devnum);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Allocate memory for our private */
|
2015-04-30 17:33:02 +08:00
|
|
|
sisusb = kzalloc(sizeof(*sisusb), GFP_KERNEL);
|
2016-01-16 01:41:33 +08:00
|
|
|
if (!sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENOMEM;
|
2016-01-16 01:41:33 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
kref_init(&sisusb->kref);
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_init(&(sisusb->lock));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2019-05-09 20:41:50 +08:00
|
|
|
sisusb->sisusb_dev = dev;
|
|
|
|
sisusb->vrambase = SISUSB_PCI_MEMBASE;
|
|
|
|
sisusb->mmiobase = SISUSB_PCI_MMIOBASE;
|
|
|
|
sisusb->mmiosize = SISUSB_PCI_MMIOSIZE;
|
|
|
|
sisusb->ioportbase = SISUSB_PCI_IOPORTBASE;
|
|
|
|
/* Everything else is zero */
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Register device */
|
2015-04-30 17:33:02 +08:00
|
|
|
retval = usb_register_dev(intf, &usb_sisusb_class);
|
|
|
|
if (retval) {
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_err(&sisusb->sisusb_dev->dev,
|
|
|
|
"Failed to get a minor for device %d\n",
|
|
|
|
dev->devnum);
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = -ENODEV;
|
|
|
|
goto error_1;
|
|
|
|
}
|
|
|
|
|
2019-05-09 20:41:50 +08:00
|
|
|
sisusb->minor = intf->minor;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Allocate buffers */
|
|
|
|
sisusb->ibufsize = SISUSB_IBUF_SIZE;
|
2016-01-16 01:41:31 +08:00
|
|
|
sisusb->ibuf = kmalloc(SISUSB_IBUF_SIZE, GFP_KERNEL);
|
|
|
|
if (!sisusb->ibuf) {
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error_2;
|
|
|
|
}
|
|
|
|
|
|
|
|
sisusb->numobufs = 0;
|
|
|
|
sisusb->obufsize = SISUSB_OBUF_SIZE;
|
|
|
|
for (i = 0; i < NUMOBUFS; i++) {
|
2016-01-16 01:41:31 +08:00
|
|
|
sisusb->obuf[i] = kmalloc(SISUSB_OBUF_SIZE, GFP_KERNEL);
|
|
|
|
if (!sisusb->obuf[i]) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (i == 0) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error_3;
|
|
|
|
}
|
|
|
|
break;
|
2016-01-16 01:41:30 +08:00
|
|
|
}
|
|
|
|
sisusb->numobufs++;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate URBs */
|
2016-01-16 01:41:31 +08:00
|
|
|
sisusb->sisurbin = usb_alloc_urb(0, GFP_KERNEL);
|
|
|
|
if (!sisusb->sisurbin) {
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error_3;
|
|
|
|
}
|
|
|
|
sisusb->completein = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < sisusb->numobufs; i++) {
|
2016-01-16 01:41:31 +08:00
|
|
|
sisusb->sisurbout[i] = usb_alloc_urb(0, GFP_KERNEL);
|
|
|
|
if (!sisusb->sisurbout[i]) {
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error_4;
|
|
|
|
}
|
|
|
|
sisusb->urbout_context[i].sisusb = (void *)sisusb;
|
|
|
|
sisusb->urbout_context[i].urbindex = i;
|
|
|
|
sisusb->urbstatus[i] = 0;
|
|
|
|
}
|
|
|
|
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_info(&sisusb->sisusb_dev->dev, "Allocated %d output buffers\n",
|
|
|
|
sisusb->numobufs);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Do remaining init stuff */
|
|
|
|
|
|
|
|
init_waitqueue_head(&sisusb->wait_q);
|
|
|
|
|
|
|
|
usb_set_intfdata(intf, sisusb);
|
|
|
|
|
2005-08-29 23:01:16 +08:00
|
|
|
usb_get_dev(sisusb->sisusb_dev);
|
|
|
|
|
|
|
|
sisusb->present = 1;
|
|
|
|
|
2016-05-02 19:09:30 +08:00
|
|
|
if (dev->speed == USB_SPEED_HIGH || dev->speed >= USB_SPEED_SUPER) {
|
2005-08-29 23:01:16 +08:00
|
|
|
int initscreen = 1;
|
|
|
|
if (sisusb_init_gfxdevice(sisusb, initscreen))
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_err(&sisusb->sisusb_dev->dev,
|
|
|
|
"Failed to early initialize device\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
} else
|
2016-01-16 01:41:29 +08:00
|
|
|
dev_info(&sisusb->sisusb_dev->dev,
|
|
|
|
"Not attached to USB 2.0 hub, deferring init\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
sisusb->ready = 1;
|
|
|
|
|
2005-08-29 23:01:16 +08:00
|
|
|
#ifdef SISUSBENDIANTEST
|
2007-08-15 22:38:12 +08:00
|
|
|
dev_dbg(&sisusb->sisusb_dev->dev, "*** RWTEST ***\n");
|
2005-08-29 23:01:16 +08:00
|
|
|
sisusb_testreadwrite(sisusb);
|
2007-08-15 22:38:12 +08:00
|
|
|
dev_dbg(&sisusb->sisusb_dev->dev, "*** RWTEST END ***\n");
|
2005-08-29 23:01:16 +08:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_4:
|
|
|
|
sisusb_free_urbs(sisusb);
|
|
|
|
error_3:
|
|
|
|
sisusb_free_buffers(sisusb);
|
|
|
|
error_2:
|
|
|
|
usb_deregister_dev(intf, &usb_sisusb_class);
|
|
|
|
error_1:
|
|
|
|
kfree(sisusb);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sisusb_disconnect(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
struct sisusb_usb_data *sisusb;
|
|
|
|
|
|
|
|
/* This should *not* happen */
|
2015-04-30 17:33:02 +08:00
|
|
|
sisusb = usb_get_intfdata(intf);
|
|
|
|
if (!sisusb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
2005-08-29 23:01:16 +08:00
|
|
|
|
USB: prevent char device open/deregister race
This patch (as908) adds central protection in usbcore for the
prototypical race between opening and unregistering a char device.
The spinlock used to protect the minor-numbers array is replaced with
an rwsem, which can remain locked across a call to a driver's open()
method. This guarantees that open() and deregister() will be mutually
exclusive.
The private locks currently used in several individual drivers for
this purpose are no longer necessary, and the patch removes them. The
following USB drivers are affected: usblcd, idmouse, auerswald,
legousbtower, sisusbvga/sisusb, ldusb, adutux, iowarrior, and
usb-skeleton.
As a side effect of this change, usb_deregister_dev() must not be
called while holding a lock that is acquired by open(). Unfortunately
a number of drivers do this, but luckily the solution is simple: call
usb_deregister_dev() before acquiring the lock.
In addition to these changes (and their consequent code
simplifications), the patch fixes a use-after-free bug in adutux and a
race between open() and release() in iowarrior.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-05-22 23:46:41 +08:00
|
|
|
usb_deregister_dev(intf, &usb_sisusb_class);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_lock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Wait for all URBs to complete and kill them in case (MUST do) */
|
|
|
|
if (!sisusb_wait_all_out_complete(sisusb))
|
|
|
|
sisusb_kill_all_busy(sisusb);
|
|
|
|
|
|
|
|
usb_set_intfdata(intf, NULL);
|
|
|
|
|
|
|
|
sisusb->present = 0;
|
|
|
|
sisusb->ready = 0;
|
|
|
|
|
2006-03-28 17:00:21 +08:00
|
|
|
mutex_unlock(&sisusb->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* decrement our usage count */
|
|
|
|
kref_put(&sisusb->kref, sisusb_delete);
|
|
|
|
}
|
|
|
|
|
2010-01-10 22:34:45 +08:00
|
|
|
static const struct usb_device_id sisusb_table[] = {
|
2007-09-01 04:40:40 +08:00
|
|
|
{ USB_DEVICE(0x0711, 0x0550) },
|
2005-04-17 06:20:36 +08:00
|
|
|
{ USB_DEVICE(0x0711, 0x0900) },
|
2006-09-01 10:32:28 +08:00
|
|
|
{ USB_DEVICE(0x0711, 0x0901) },
|
|
|
|
{ USB_DEVICE(0x0711, 0x0902) },
|
2008-11-05 02:44:01 +08:00
|
|
|
{ USB_DEVICE(0x0711, 0x0903) },
|
2008-08-21 19:46:11 +08:00
|
|
|
{ USB_DEVICE(0x0711, 0x0918) },
|
2010-01-21 01:31:09 +08:00
|
|
|
{ USB_DEVICE(0x0711, 0x0920) },
|
2013-07-05 05:47:52 +08:00
|
|
|
{ USB_DEVICE(0x0711, 0x0950) },
|
2014-08-26 12:07:47 +08:00
|
|
|
{ USB_DEVICE(0x0711, 0x5200) },
|
2005-04-19 08:39:28 +08:00
|
|
|
{ USB_DEVICE(0x182d, 0x021c) },
|
2005-04-23 06:06:59 +08:00
|
|
|
{ USB_DEVICE(0x182d, 0x0269) },
|
2005-04-17 06:20:36 +08:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2016-01-16 01:41:28 +08:00
|
|
|
MODULE_DEVICE_TABLE(usb, sisusb_table);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static struct usb_driver sisusb_driver = {
|
|
|
|
.name = "sisusb",
|
|
|
|
.probe = sisusb_probe,
|
|
|
|
.disconnect = sisusb_disconnect,
|
2005-04-19 08:39:28 +08:00
|
|
|
.id_table = sisusb_table,
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2022-12-08 17:07:48 +08:00
|
|
|
module_usb_driver(sisusb_driver);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Thomas Winischhofer <thomas@winischhofer.net>");
|
2005-08-29 23:01:16 +08:00
|
|
|
MODULE_DESCRIPTION("sisusbvga - Driver for Net2280/SiS315-based USB2VGA dongles");
|
2005-04-17 06:20:36 +08:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|