?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove all inclusions of <linux/config.h>
[linux-2.6/btrfs-unstable.git] / drivers / usb / misc / sisusbvga / sisusb.c
bloba287836e39f19178d3b62ee2ccc208ec94e22863
1 /*
2 * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
3 *
4 * Main part
5 *
6 * Copyright (C) 2005 by Thomas Winischhofer, Vienna, Austria
7 *
8 * If distributed as part of the Linux kernel, this code is licensed under the
9 * terms of the GPL v2.
10 *
11 * Otherwise, the following license terms apply:
12 *
13 * * Redistribution and use in source and binary forms, with or without
14 * * modification, are permitted provided that the following conditions
15 * * are met:
16 * * 1) Redistributions of source code must retain the above copyright
17 * * notice, this list of conditions and the following disclaimer.
18 * * 2) Redistributions in binary form must reproduce the above copyright
19 * * notice, this list of conditions and the following disclaimer in the
20 * * documentation and/or other materials provided with the distribution.
21 * * 3) The name of the author may not be used to endorse or promote products
22 * * derived from this software without specific psisusbr written permission.
23 * *
24 * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESSED OR
25 * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26 * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27 * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29 * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33 * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 * Author: Thomas Winischhofer <thomas@winischhofer.net>
36 *
37 */
38
39 #include <linux/mutex.h>
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/signal.h>
43 #include <linux/sched.h>
44 #include <linux/errno.h>
45 #include <linux/poll.h>
46 #include <linux/init.h>
47 #include <linux/slab.h>
48 #include <linux/spinlock.h>
49 #include <linux/kref.h>
50 #include <linux/usb.h>
51 #include <linux/smp_lock.h>
52 #include <linux/vmalloc.h>
53
54 #include "sisusb.h"
55 #include "sisusb_init.h"
56
57 #ifdef INCL_SISUSB_CON
58 #include <linux/font.h>
59 #endif
60
61 #define SISUSB_DONTSYNC
62
63 /* Forward declarations / clean-up routines */
64
65 #ifdef INCL_SISUSB_CON
66 static int sisusb_first_vc = 0;
67 static int sisusb_last_vc = 0;
68 module_param_named(first, sisusb_first_vc, int, 0);
69 module_param_named(last, sisusb_last_vc, int, 0);
70 MODULE_PARM_DESC(first, "Number of first console to take over (1 - MAX_NR_CONSOLES)");
71 MODULE_PARM_DESC(last, "Number of last console to take over (1 - MAX_NR_CONSOLES)");
72 #endif
73
74 static struct usb_driver sisusb_driver;
75
76 DEFINE_MUTEX(disconnect_mutex);
77
78 static void
79 sisusb_free_buffers(struct sisusb_usb_data *sisusb)
80 {
81 int i;
82
83 for (i = 0; i < NUMOBUFS; i++) {
84 if (sisusb->obuf[i]) {
85 usb_buffer_free(sisusb->sisusb_dev, sisusb->obufsize,
86 sisusb->obuf[i], sisusb->transfer_dma_out[i]);
87 sisusb->obuf[i] = NULL;
88 }
89 }
90 if (sisusb->ibuf) {
91 usb_buffer_free(sisusb->sisusb_dev, sisusb->ibufsize,
92 sisusb->ibuf, sisusb->transfer_dma_in);
93 sisusb->ibuf = NULL;
94 }
95 }
96
97 static void
98 sisusb_free_urbs(struct sisusb_usb_data *sisusb)
99 {
100 int i;
101
102 for (i = 0; i < NUMOBUFS; i++) {
103 usb_free_urb(sisusb->sisurbout[i]);
104 sisusb->sisurbout[i] = NULL;
105 }
106 usb_free_urb(sisusb->sisurbin);
107 sisusb->sisurbin = NULL;
108 }
109
110 /* Level 0: USB transport layer */
111
112 /* 1. out-bulks */
113
114 /* out-urb management */
115
116 /* Return 1 if all free, 0 otherwise */
117 static int
118 sisusb_all_free(struct sisusb_usb_data *sisusb)
119 {
120 int i;
121
122 for (i = 0; i < sisusb->numobufs; i++) {
123
124 if (sisusb->urbstatus[i] & SU_URB_BUSY)
125 return 0;
126
127 }
128
129 return 1;
130 }
131
132 /* Kill all busy URBs */
133 static void
134 sisusb_kill_all_busy(struct sisusb_usb_data *sisusb)
135 {
136 int i;
137
138 if (sisusb_all_free(sisusb))
139 return;
140
141 for (i = 0; i < sisusb->numobufs; i++) {
142
143 if (sisusb->urbstatus[i] & SU_URB_BUSY)
144 usb_kill_urb(sisusb->sisurbout[i]);
145
146 }
147 }
148
149 /* Return 1 if ok, 0 if error (not all complete within timeout) */
150 static int
151 sisusb_wait_all_out_complete(struct sisusb_usb_data *sisusb)
152 {
153 int timeout = 5 * HZ, i = 1;
154
155 wait_event_timeout(sisusb->wait_q,
156 (i = sisusb_all_free(sisusb)),
157 timeout);
158
159 return i;
160 }
161
162 static int
163 sisusb_outurb_available(struct sisusb_usb_data *sisusb)
164 {
165 int i;
166
167 for (i = 0; i < sisusb->numobufs; i++) {
168
169 if ((sisusb->urbstatus[i] & (SU_URB_BUSY|SU_URB_ALLOC)) == 0)
170 return i;
171
172 }
173
174 return -1;
175 }
176
177 static int
178 sisusb_get_free_outbuf(struct sisusb_usb_data *sisusb)
179 {
180 int i, timeout = 5 * HZ;
181
182 wait_event_timeout(sisusb->wait_q,
183 ((i = sisusb_outurb_available(sisusb)) >= 0),
184 timeout);
185
186 return i;
187 }
188
189 static int
190 sisusb_alloc_outbuf(struct sisusb_usb_data *sisusb)
191 {
192 int i;
193
194 i = sisusb_outurb_available(sisusb);
195
196 if (i >= 0)
197 sisusb->urbstatus[i] |= SU_URB_ALLOC;
198
199 return i;
200 }
201
202 static void
203 sisusb_free_outbuf(struct sisusb_usb_data *sisusb, int index)
204 {
205 if ((index >= 0) && (index < sisusb->numobufs))
206 sisusb->urbstatus[index] &= ~SU_URB_ALLOC;
207 }
208
209 /* completion callback */
210
211 static void
212 sisusb_bulk_completeout(struct urb *urb, struct pt_regs *regs)
213 {
214 struct sisusb_urb_context *context = urb->context;
215 struct sisusb_usb_data *sisusb;
216
217 if (!context)
218 return;
219
220 sisusb = context->sisusb;
221
222 if (!sisusb || !sisusb->sisusb_dev || !sisusb->present)
223 return;
224
225 #ifndef SISUSB_DONTSYNC
226 if (context->actual_length)
227 *(context->actual_length) += urb->actual_length;
228 #endif
229
230 sisusb->urbstatus[context->urbindex] &= ~SU_URB_BUSY;
231 wake_up(&sisusb->wait_q);
232 }
233
234 static int
235 sisusb_bulkout_msg(struct sisusb_usb_data *sisusb, int index, unsigned int pipe, void *data,
236 int len, int *actual_length, int timeout, unsigned int tflags,
237 dma_addr_t transfer_dma)
238 {
239 struct urb *urb = sisusb->sisurbout[index];
240 int retval, byteswritten = 0;
241
242 /* Set up URB */
243 urb->transfer_flags = 0;
244
245 usb_fill_bulk_urb(urb, sisusb->sisusb_dev, pipe, data, len,
246 sisusb_bulk_completeout, &sisusb->urbout_context[index]);
247
248 urb->transfer_flags |= tflags;
249 urb->actual_length = 0;
250
251 if ((urb->transfer_dma = transfer_dma))
252 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
253
254 /* Set up context */
255 sisusb->urbout_context[index].actual_length = (timeout) ?
256 NULL : actual_length;
257
258 /* Declare this urb/buffer in use */
259 sisusb->urbstatus[index] |= SU_URB_BUSY;
260
261 /* Submit URB */
262 retval = usb_submit_urb(urb, GFP_ATOMIC);
263
264 /* If OK, and if timeout > 0, wait for completion */
265 if ((retval == 0) && timeout) {
266 wait_event_timeout(sisusb->wait_q,
267 (!(sisusb->urbstatus[index] & SU_URB_BUSY)),
268 timeout);
269 if (sisusb->urbstatus[index] & SU_URB_BUSY) {
270 /* URB timed out... kill it and report error */
271 usb_kill_urb(urb);
272 retval = -ETIMEDOUT;
273 } else {
274 /* Otherwise, report urb status */
275 retval = urb->status;
276 byteswritten = urb->actual_length;
277 }
278 }
279
280 if (actual_length)
281 *actual_length = byteswritten;
282
283 return retval;
284 }
285
286 /* 2. in-bulks */
287
288 /* completion callback */
289
290 static void
291 sisusb_bulk_completein(struct urb *urb, struct pt_regs *regs)
292 {
293 struct sisusb_usb_data *sisusb = urb->context;
294
295 if (!sisusb || !sisusb->sisusb_dev || !sisusb->present)
296 return;
297
298 sisusb->completein = 1;
299 wake_up(&sisusb->wait_q);
300 }
301
302 static int
303 sisusb_bulkin_msg(struct sisusb_usb_data *sisusb, unsigned int pipe, void *data, int len,
304 int *actual_length, int timeout, unsigned int tflags, dma_addr_t transfer_dma)
305 {
306 struct urb *urb = sisusb->sisurbin;
307 int retval, readbytes = 0;
308
309 urb->transfer_flags = 0;
310
311 usb_fill_bulk_urb(urb, sisusb->sisusb_dev, pipe, data, len,
312 sisusb_bulk_completein, sisusb);
313
314 urb->transfer_flags |= tflags;
315 urb->actual_length = 0;
316
317 if ((urb->transfer_dma = transfer_dma))
318 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
319
320 sisusb->completein = 0;
321 retval = usb_submit_urb(urb, GFP_ATOMIC);
322 if (retval == 0) {
323 wait_event_timeout(sisusb->wait_q, sisusb->completein, timeout);
324 if (!sisusb->completein) {
325 /* URB timed out... kill it and report error */
326 usb_kill_urb(urb);
327 retval = -ETIMEDOUT;
328 } else {
329 /* URB completed within timout */
330 retval = urb->status;
331 readbytes = urb->actual_length;
332 }
333 }
334
335 if (actual_length)
336 *actual_length = readbytes;
337
338 return retval;
339 }
340
341
342 /* Level 1: */
343
344 /* Send a bulk message of variable size
345 *
346 * To copy the data from userspace, give pointer to "userbuffer",
347 * to copy from (non-DMA) kernel memory, give "kernbuffer". If
348 * both of these are NULL, it is assumed, that the transfer
349 * buffer "sisusb->obuf[index]" is set up with the data to send.
350 * Index is ignored if either kernbuffer or userbuffer is set.
351 * If async is nonzero, URBs will be sent without waiting for
352 * completion of the previous URB.
353 *
354 * (return 0 on success)
355 */
356
357 static int sisusb_send_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
358 char *kernbuffer, const char __user *userbuffer, int index,
359 ssize_t *bytes_written, unsigned int tflags, int async)
360 {
361 int result = 0, retry, count = len;
362 int passsize, thispass, transferred_len = 0;
363 int fromuser = (userbuffer != NULL) ? 1 : 0;
364 int fromkern = (kernbuffer != NULL) ? 1 : 0;
365 unsigned int pipe;
366 char *buffer;
367
368 (*bytes_written) = 0;
369
370 /* Sanity check */
371 if (!sisusb || !sisusb->present || !sisusb->sisusb_dev)
372 return -ENODEV;
373
374 /* If we copy data from kernel or userspace, force the
375 * allocation of a buffer/urb. If we have the data in
376 * the transfer buffer[index] already, reuse the buffer/URB
377 * if the length is > buffer size. (So, transmitting
378 * large data amounts directly from the transfer buffer
379 * treats the buffer as a ring buffer. However, we need
380 * to sync in this case.)
381 */
382 if (fromuser || fromkern)
383 index = -1;
384 else if (len > sisusb->obufsize)
385 async = 0;
386
387 pipe = usb_sndbulkpipe(sisusb->sisusb_dev, ep);
388
389 do {
390 passsize = thispass = (sisusb->obufsize < count) ?
391 sisusb->obufsize : count;
392
393 if (index < 0)
394 index = sisusb_get_free_outbuf(sisusb);
395
396 if (index < 0)
397 return -EIO;
398
399 buffer = sisusb->obuf[index];
400
401 if (fromuser) {
402
403 if (copy_from_user(buffer, userbuffer, passsize))
404 return -EFAULT;
405
406 userbuffer += passsize;
407
408 } else if (fromkern) {
409
410 memcpy(buffer, kernbuffer, passsize);
411 kernbuffer += passsize;
412
413 }
414
415 retry = 5;
416 while (thispass) {
417
418 if (!sisusb->sisusb_dev)
419 return -ENODEV;
420
421 result = sisusb_bulkout_msg(sisusb,
422 index,
423 pipe,
424 buffer,
425 thispass,
426 &transferred_len,
427 async ? 0 : 5 * HZ,
428 tflags,
429 sisusb->transfer_dma_out[index]);
430
431 if (result == -ETIMEDOUT) {
432
433 /* Will not happen if async */
434 if (!retry--)
435 return -ETIME;
436
437 continue;
438
439 } else if ((result == 0) && !async && transferred_len) {
440
441 thispass -= transferred_len;
442 if (thispass) {
443 if (sisusb->transfer_dma_out) {
444 /* If DMA, copy remaining
445 * to beginning of buffer
446 */
447 memcpy(buffer,
448 buffer + transferred_len,
449 thispass);
450 } else {
451 /* If not DMA, simply increase
452 * the pointer
453 */
454 buffer += transferred_len;
455 }
456 }
457
458 } else
459 break;
460 };
461
462 if (result)
463 return result;
464
465 (*bytes_written) += passsize;
466 count -= passsize;
467
468 /* Force new allocation in next iteration */
469 if (fromuser || fromkern)
470 index = -1;
471
472 } while (count > 0);
473
474 if (async) {
475 #ifdef SISUSB_DONTSYNC
476 (*bytes_written) = len;
477 /* Some URBs/buffers might be busy */
478 #else
479 sisusb_wait_all_out_complete(sisusb);
480 (*bytes_written) = transferred_len;
481 /* All URBs and all buffers are available */
482 #endif
483 }
484
485 return ((*bytes_written) == len) ? 0 : -EIO;
486 }
487
488 /* Receive a bulk message of variable size
489 *
490 * To copy the data to userspace, give pointer to "userbuffer",
491 * to copy to kernel memory, give "kernbuffer". One of them
492 * MUST be set. (There is no technique for letting the caller
493 * read directly from the ibuf.)
494 *
495 */
496
497 static int sisusb_recv_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
498 void *kernbuffer, char __user *userbuffer, ssize_t *bytes_read,
499 unsigned int tflags)
500 {
501 int result = 0, retry, count = len;
502 int bufsize, thispass, transferred_len;
503 unsigned int pipe;
504 char *buffer;
505
506 (*bytes_read) = 0;
507
508 /* Sanity check */
509 if (!sisusb || !sisusb->present || !sisusb->sisusb_dev)
510 return -ENODEV;
511
512 pipe = usb_rcvbulkpipe(sisusb->sisusb_dev, ep);
513 buffer = sisusb->ibuf;
514 bufsize = sisusb->ibufsize;
515
516 retry = 5;
517
518 #ifdef SISUSB_DONTSYNC
519 if (!(sisusb_wait_all_out_complete(sisusb)))
520 return -EIO;
521 #endif
522
523 while (count > 0) {
524
525 if (!sisusb->sisusb_dev)
526 return -ENODEV;
527
528 thispass = (bufsize < count) ? bufsize : count;
529
530 result = sisusb_bulkin_msg(sisusb,
531 pipe,
532 buffer,
533 thispass,
534 &transferred_len,
535 5 * HZ,
536 tflags,
537 sisusb->transfer_dma_in);
538
539 if (transferred_len)
540 thispass = transferred_len;
541
542 else if (result == -ETIMEDOUT) {
543
544 if (!retry--)
545 return -ETIME;
546
547 continue;
548
549 } else
550 return -EIO;
551
552
553 if (thispass) {
554
555 (*bytes_read) += thispass;
556 count -= thispass;
557
558 if (userbuffer) {
559
560 if (copy_to_user(userbuffer, buffer, thispass))
561 return -EFAULT;
562
563 userbuffer += thispass;
564
565 } else {
566
567 memcpy(kernbuffer, buffer, thispass);
568 kernbuffer += thispass;
569
570 }
571
572 }
573
574 }
575
576 return ((*bytes_read) == len) ? 0 : -EIO;
577 }
578
579 static int sisusb_send_packet(struct sisusb_usb_data *sisusb, int len,
580 struct sisusb_packet *packet)
581 {
582 int ret;
583 ssize_t bytes_transferred = 0;
584 __le32 tmp;
585
586 if (len == 6)
587 packet->data = 0;
588
589 #ifdef SISUSB_DONTSYNC
590 if (!(sisusb_wait_all_out_complete(sisusb)))
591 return 1;
592 #endif
593
594 /* Eventually correct endianness */
595 SISUSB_CORRECT_ENDIANNESS_PACKET(packet);
596
597 /* 1. send the packet */
598 ret = sisusb_send_bulk_msg(sisusb, SISUSB_EP_GFX_OUT, len,
599 (char *)packet, NULL, 0, &bytes_transferred, 0, 0);
600
601 if ((ret == 0) && (len == 6)) {
602
603 /* 2. if packet len == 6, it means we read, so wait for 32bit
604 * return value and write it to packet->data
605 */
606 ret = sisusb_recv_bulk_msg(sisusb, SISUSB_EP_GFX_IN, 4,
607 (char *)&tmp, NULL, &bytes_transferred, 0);
608
609 packet->data = le32_to_cpu(tmp);
610 }
611
612 return ret;
613 }
614
615 static int sisusb_send_bridge_packet(struct sisusb_usb_data *sisusb, int len,
616 struct sisusb_packet *packet,
617 unsigned int tflags)
618 {
619 int ret;
620 ssize_t bytes_transferred = 0;
621 __le32 tmp;
622
623 if (len == 6)
624 packet->data = 0;
625
626 #ifdef SISUSB_DONTSYNC
627 if (!(sisusb_wait_all_out_complete(sisusb)))
628 return 1;
629 #endif
630
631 /* Eventually correct endianness */
632 SISUSB_CORRECT_ENDIANNESS_PACKET(packet);
633
634 /* 1. send the packet */
635 ret = sisusb_send_bulk_msg(sisusb, SISUSB_EP_BRIDGE_OUT, len,
636 (char *)packet, NULL, 0, &bytes_transferred, tflags, 0);
637
638 if ((ret == 0) && (len == 6)) {
639
640 /* 2. if packet len == 6, it means we read, so wait for 32bit
641 * return value and write it to packet->data
642 */
643 ret = sisusb_recv_bulk_msg(sisusb, SISUSB_EP_BRIDGE_IN, 4,
644 (char *)&tmp, NULL, &bytes_transferred, 0);
645
646 packet->data = le32_to_cpu(tmp);
647 }
648
649 return ret;
650 }
651
652 /* access video memory and mmio (return 0 on success) */
653
654 /* Low level */
655
656 /* The following routines assume being used to transfer byte, word,
657 * long etc.
658 * This means that
659 * - the write routines expect "data" in machine endianness format.
660 * The data will be converted to leXX in sisusb_xxx_packet.
661 * - the read routines can expect read data in machine-endianess.
662 */
663
664 static int sisusb_write_memio_byte(struct sisusb_usb_data *sisusb, int type,
665 u32 addr, u8 data)
666 {
667 struct sisusb_packet packet;
668 int ret;
669
670 packet.header = (1 << (addr & 3)) | (type << 6);
671 packet.address = addr & ~3;
672 packet.data = data << ((addr & 3) << 3);
673 ret = sisusb_send_packet(sisusb, 10, &packet);
674 return ret;
675 }
676
677 static int sisusb_write_memio_word(struct sisusb_usb_data *sisusb, int type,
678 u32 addr, u16 data)
679 {
680 struct sisusb_packet packet;
681 int ret = 0;
682
683 packet.address = addr & ~3;
684
685 switch (addr & 3) {
686 case 0:
687 packet.header = (type << 6) | 0x0003;
688 packet.data = (u32)data;
689 ret = sisusb_send_packet(sisusb, 10, &packet);
690 break;
691 case 1:
692 packet.header = (type << 6) | 0x0006;
693 packet.data = (u32)data << 8;
694 ret = sisusb_send_packet(sisusb, 10, &packet);
695 break;
696 case 2:
697 packet.header = (type << 6) | 0x000c;
698 packet.data = (u32)data << 16;
699 ret = sisusb_send_packet(sisusb, 10, &packet);
700 break;
701 case 3:
702 packet.header = (type << 6) | 0x0008;
703 packet.data = (u32)data << 24;
704 ret = sisusb_send_packet(sisusb, 10, &packet);
705 packet.header = (type << 6) | 0x0001;
706 packet.address = (addr & ~3) + 4;
707 packet.data = (u32)data >> 8;
708 ret |= sisusb_send_packet(sisusb, 10, &packet);
709 }
710
711 return ret;
712 }
713
714 static int sisusb_write_memio_24bit(struct sisusb_usb_data *sisusb, int type,
715 u32 addr, u32 data)
716 {
717 struct sisusb_packet packet;
718 int ret = 0;
719
720 packet.address = addr & ~3;
721
722 switch (addr & 3) {
723 case 0:
724 packet.header = (type << 6) | 0x0007;
725 packet.data = data & 0x00ffffff;
726 ret = sisusb_send_packet(sisusb, 10, &packet);
727 break;
728 case 1:
729 packet.header = (type << 6) | 0x000e;
730 packet.data = data << 8;
731 ret = sisusb_send_packet(sisusb, 10, &packet);
732 break;
733 case 2:
734 packet.header = (type << 6) | 0x000c;
735 packet.data = data << 16;
736 ret = sisusb_send_packet(sisusb, 10, &packet);
737 packet.header = (type << 6) | 0x0001;
738 packet.address = (addr & ~3) + 4;
739 packet.data = (data >> 16) & 0x00ff;
740 ret |= sisusb_send_packet(sisusb, 10, &packet);
741 break;
742 case 3:
743 packet.header = (type << 6) | 0x0008;
744 packet.data = data << 24;
745 ret = sisusb_send_packet(sisusb, 10, &packet);
746 packet.header = (type << 6) | 0x0003;
747 packet.address = (addr & ~3) + 4;
748 packet.data = (data >> 8) & 0xffff;
749 ret |= sisusb_send_packet(sisusb, 10, &packet);
750 }
751
752 return ret;
753 }
754
755 static int sisusb_write_memio_long(struct sisusb_usb_data *sisusb, int type,
756 u32 addr, u32 data)
757 {
758 struct sisusb_packet packet;
759 int ret = 0;
760
761 packet.address = addr & ~3;
762
763 switch (addr & 3) {
764 case 0:
765 packet.header = (type << 6) | 0x000f;
766 packet.data = data;
767 ret = sisusb_send_packet(sisusb, 10, &packet);
768 break;
769 case 1:
770 packet.header = (type << 6) | 0x000e;
771 packet.data = data << 8;
772 ret = sisusb_send_packet(sisusb, 10, &packet);
773 packet.header = (type << 6) | 0x0001;
774 packet.address = (addr & ~3) + 4;
775 packet.data = data >> 24;
776 ret |= sisusb_send_packet(sisusb, 10, &packet);
777 break;
778 case 2:
779 packet.header = (type << 6) | 0x000c;
780 packet.data = data << 16;
781 ret = sisusb_send_packet(sisusb, 10, &packet);
782 packet.header = (type << 6) | 0x0003;
783 packet.address = (addr & ~3) + 4;
784 packet.data = data >> 16;
785 ret |= sisusb_send_packet(sisusb, 10, &packet);
786 break;
787 case 3:
788 packet.header = (type << 6) | 0x0008;
789 packet.data = data << 24;
790 ret = sisusb_send_packet(sisusb, 10, &packet);
791 packet.header = (type << 6) | 0x0007;
792 packet.address = (addr & ~3) + 4;
793 packet.data = data >> 8;
794 ret |= sisusb_send_packet(sisusb, 10, &packet);
795 }
796
797 return ret;
798 }
799
800 /* The xxx_bulk routines copy a buffer of variable size. They treat the
801 * buffer as chars, therefore lsb/msb has to be corrected if using the
802 * byte/word/long/etc routines for speed-up
803 *
804 * If data is from userland, set "userbuffer" (and clear "kernbuffer"),
805 * if data is in kernel space, set "kernbuffer" (and clear "userbuffer");
806 * if neither "kernbuffer" nor "userbuffer" are given, it is assumed
807 * that the data already is in the transfer buffer "sisusb->obuf[index]".
808 */
809
810 static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
811 char *kernbuffer, int length,
812 const char __user *userbuffer, int index,
813 ssize_t *bytes_written)
814 {
815 struct sisusb_packet packet;
816 int ret = 0;
817 static int msgcount = 0;
818 u8 swap8, fromkern = kernbuffer ? 1 : 0;
819 u16 swap16;
820 u32 swap32, flag = (length >> 28) & 1;
821 char buf[4];
822
823 /* if neither kernbuffer not userbuffer are given, assume
824 * data in obuf
825 */
826 if (!fromkern && !userbuffer)
827 kernbuffer = sisusb->obuf[index];
828
829 (*bytes_written = 0);
830
831 length &= 0x00ffffff;
832
833 while (length) {
834
835 switch (length) {
836
837 case 1:
838 if (userbuffer) {
839 if (get_user(swap8, (u8 __user *)userbuffer))
840 return -EFAULT;
841 } else
842 swap8 = kernbuffer[0];
843
844 ret = sisusb_write_memio_byte(sisusb,
845 SISUSB_TYPE_MEM,
846 addr, swap8);
847
848 if (!ret)
849 (*bytes_written)++;
850
851 return ret;
852
853 case 2:
854 if (userbuffer) {
855 if (get_user(swap16, (u16 __user *)userbuffer))
856 return -EFAULT;
857 } else
858 swap16 = *((u16 *)kernbuffer);
859
860 ret = sisusb_write_memio_word(sisusb,
861 SISUSB_TYPE_MEM,
862 addr,
863 swap16);
864
865 if (!ret)
866 (*bytes_written) += 2;
867
868 return ret;
869
870 case 3:
871 if (userbuffer) {
872 if (copy_from_user(&buf, userbuffer, 3))
873 return -EFAULT;
874 #ifdef __BIG_ENDIAN
875 swap32 = (buf[0] << 16) |
876 (buf[1] << 8) |
877 buf[2];
878 #else
879 swap32 = (buf[2] << 16) |
880 (buf[1] << 8) |
881 buf[0];
882 #endif
883 } else
884 #ifdef __BIG_ENDIAN
885 swap32 = (kernbuffer[0] << 16) |
886 (kernbuffer[1] << 8) |
887 kernbuffer[2];
888 #else
889 swap32 = (kernbuffer[2] << 16) |
890 (kernbuffer[1] << 8) |
891 kernbuffer[0];
892 #endif
893
894 ret = sisusb_write_memio_24bit(sisusb,
895 SISUSB_TYPE_MEM,
896 addr,
897 swap32);
898
899 if (!ret)
900 (*bytes_written) += 3;
901
902 return ret;
903
904 case 4:
905 if (userbuffer) {
906 if (get_user(swap32, (u32 __user *)userbuffer))
907 return -EFAULT;
908 } else
909 swap32 = *((u32 *)kernbuffer);
910
911 ret = sisusb_write_memio_long(sisusb,
912 SISUSB_TYPE_MEM,
913 addr,
914 swap32);
915 if (!ret)
916 (*bytes_written) += 4;
917
918 return ret;
919
920 default:
921 if ((length & ~3) > 0x10000) {
922
923 packet.header = 0x001f;
924 packet.address = 0x000001d4;
925 packet.data = addr;
926 ret = sisusb_send_bridge_packet(sisusb, 10,
927 &packet, 0);
928 packet.header = 0x001f;
929 packet.address = 0x000001d0;
930 packet.data = (length & ~3);
931 ret |= sisusb_send_bridge_packet(sisusb, 10,
932 &packet, 0);
933 packet.header = 0x001f;
934 packet.address = 0x000001c0;
935 packet.data = flag | 0x16;
936 ret |= sisusb_send_bridge_packet(sisusb, 10,
937 &packet, 0);
938 if (userbuffer) {
939 ret |= sisusb_send_bulk_msg(sisusb,
940 SISUSB_EP_GFX_LBULK_OUT,
941 (length & ~3),
942 NULL, userbuffer, 0,
943 bytes_written, 0, 1);
944 userbuffer += (*bytes_written);
945 } else if (fromkern) {
946 ret |= sisusb_send_bulk_msg(sisusb,
947 SISUSB_EP_GFX_LBULK_OUT,
948 (length & ~3),
949 kernbuffer, NULL, 0,
950 bytes_written, 0, 1);
951 kernbuffer += (*bytes_written);
952 } else {
953 ret |= sisusb_send_bulk_msg(sisusb,
954 SISUSB_EP_GFX_LBULK_OUT,
955 (length & ~3),
956 NULL, NULL, index,
957 bytes_written, 0, 1);
958 kernbuffer += ((*bytes_written) &
959 (sisusb->obufsize-1));
960 }
961
962 } else {
963
964 packet.header = 0x001f;
965 packet.address = 0x00000194;
966 packet.data = addr;
967 ret = sisusb_send_bridge_packet(sisusb, 10,
968 &packet, 0);
969 packet.header = 0x001f;
970 packet.address = 0x00000190;
971 packet.data = (length & ~3);
972 ret |= sisusb_send_bridge_packet(sisusb, 10,
973 &packet, 0);
974 if (sisusb->flagb0 != 0x16) {
975 packet.header = 0x001f;
976 packet.address = 0x00000180;
977 packet.data = flag | 0x16;
978 ret |= sisusb_send_bridge_packet(sisusb, 10,
979 &packet, 0);
980 sisusb->flagb0 = 0x16;
981 }
982 if (userbuffer) {
983 ret |= sisusb_send_bulk_msg(sisusb,
984 SISUSB_EP_GFX_BULK_OUT,
985 (length & ~3),
986 NULL, userbuffer, 0,
987 bytes_written, 0, 1);
988 userbuffer += (*bytes_written);
989 } else if (fromkern) {
990 ret |= sisusb_send_bulk_msg(sisusb,
991 SISUSB_EP_GFX_BULK_OUT,
992 (length & ~3),
993 kernbuffer, NULL, 0,
994 bytes_written, 0, 1);
995 kernbuffer += (*bytes_written);
996 } else {
997 ret |= sisusb_send_bulk_msg(sisusb,
998 SISUSB_EP_GFX_BULK_OUT,
999 (length & ~3),
1000 NULL, NULL, index,
1001 bytes_written, 0, 1);
1002 kernbuffer += ((*bytes_written) &
1003 (sisusb->obufsize-1));
1004 }
1005 }
1006 if (ret) {
1007 msgcount++;
1008 if (msgcount < 500)
1009 printk(KERN_ERR
1010 "sisusbvga[%d]: Wrote %zd of "
1011 "%d bytes, error %d\n",
1012 sisusb->minor, *bytes_written,
1013 length, ret);
1014 else if (msgcount == 500)
1015 printk(KERN_ERR
1016 "sisusbvga[%d]: Too many errors"
1017 ", logging stopped\n",
1018 sisusb->minor);
1019 }
1020 addr += (*bytes_written);
1021 length -= (*bytes_written);
1022 }
1023
1024 if (ret)
1025 break;
1026
1027 }
1028
1029 return ret ? -EIO : 0;
1030 }
1031
1032 /* Remember: Read data in packet is in machine-endianess! So for
1033 * byte, word, 24bit, long no endian correction is necessary.
1034 */
1035
1036 static int sisusb_read_memio_byte(struct sisusb_usb_data *sisusb, int type,
1037 u32 addr, u8 *data)
1038 {
1039 struct sisusb_packet packet;
1040 int ret;
1041
1042 CLEARPACKET(&packet);
1043 packet.header = (1 << (addr & 3)) | (type << 6);
1044 packet.address = addr & ~3;
1045 ret = sisusb_send_packet(sisusb, 6, &packet);
1046 *data = (u8)(packet.data >> ((addr & 3) << 3));
1047 return ret;
1048 }
1049
1050 static int sisusb_read_memio_word(struct sisusb_usb_data *sisusb, int type,
1051 u32 addr, u16 *data)
1052 {
1053 struct sisusb_packet packet;
1054 int ret = 0;
1055
1056 CLEARPACKET(&packet);
1057
1058 packet.address = addr & ~3;
1059
1060 switch (addr & 3) {
1061 case 0:
1062 packet.header = (type << 6) | 0x0003;
1063 ret = sisusb_send_packet(sisusb, 6, &packet);
1064 *data = (u16)(packet.data);
1065 break;
1066 case 1:
1067 packet.header = (type << 6) | 0x0006;
1068 ret = sisusb_send_packet(sisusb, 6, &packet);
1069 *data = (u16)(packet.data >> 8);
1070 break;
1071 case 2:
1072 packet.header = (type << 6) | 0x000c;
1073 ret = sisusb_send_packet(sisusb, 6, &packet);
1074 *data = (u16)(packet.data >> 16);
1075 break;
1076 case 3:
1077 packet.header = (type << 6) | 0x0008;
1078 ret = sisusb_send_packet(sisusb, 6, &packet);
1079 *data = (u16)(packet.data >> 24);
1080 packet.header = (type << 6) | 0x0001;
1081 packet.address = (addr & ~3) + 4;
1082 ret |= sisusb_send_packet(sisusb, 6, &packet);
1083 *data |= (u16)(packet.data << 8);
1084 }
1085
1086 return ret;
1087 }
1088
1089 static int sisusb_read_memio_24bit(struct sisusb_usb_data *sisusb, int type,
1090 u32 addr, u32 *data)
1091 {
1092 struct sisusb_packet packet;
1093 int ret = 0;
1094
1095 packet.address = addr & ~3;
1096
1097 switch (addr & 3) {
1098 case 0:
1099 packet.header = (type << 6) | 0x0007;
1100 ret = sisusb_send_packet(sisusb, 6, &packet);
1101 *data = packet.data & 0x00ffffff;
1102 break;
1103 case 1:
1104 packet.header = (type << 6) | 0x000e;
1105 ret = sisusb_send_packet(sisusb, 6, &packet);
1106 *data = packet.data >> 8;
1107 break;
1108 case 2:
1109 packet.header = (type << 6) | 0x000c;
1110 ret = sisusb_send_packet(sisusb, 6, &packet);
1111 *data = packet.data >> 16;
1112 packet.header = (type << 6) | 0x0001;
1113 packet.address = (addr & ~3) + 4;
1114 ret |= sisusb_send_packet(sisusb, 6, &packet);
1115 *data |= ((packet.data & 0xff) << 16);
1116 break;
1117 case 3:
1118 packet.header = (type << 6) | 0x0008;
1119 ret = sisusb_send_packet(sisusb, 6, &packet);
1120 *data = packet.data >> 24;
1121 packet.header = (type << 6) | 0x0003;
1122 packet.address = (addr & ~3) + 4;
1123 ret |= sisusb_send_packet(sisusb, 6, &packet);
1124 *data |= ((packet.data & 0xffff) << 8);
1125 }
1126
1127 return ret;
1128 }
1129
1130 static int sisusb_read_memio_long(struct sisusb_usb_data *sisusb, int type,
1131 u32 addr, u32 *data)
1132 {
1133 struct sisusb_packet packet;
1134 int ret = 0;
1135
1136 packet.address = addr & ~3;
1137
1138 switch (addr & 3) {
1139 case 0:
1140 packet.header = (type << 6) | 0x000f;
1141 ret = sisusb_send_packet(sisusb, 6, &packet);
1142 *data = packet.data;
1143 break;
1144 case 1:
1145 packet.header = (type << 6) | 0x000e;
1146 ret = sisusb_send_packet(sisusb, 6, &packet);
1147 *data = packet.data >> 8;
1148 packet.header = (type << 6) | 0x0001;
1149 packet.address = (addr & ~3) + 4;
1150 ret |= sisusb_send_packet(sisusb, 6, &packet);
1151 *data |= (packet.data << 24);
1152 break;
1153 case 2:
1154 packet.header = (type << 6) | 0x000c;
1155 ret = sisusb_send_packet(sisusb, 6, &packet);
1156 *data = packet.data >> 16;
1157 packet.header = (type << 6) | 0x0003;
1158 packet.address = (addr & ~3) + 4;
1159 ret |= sisusb_send_packet(sisusb, 6, &packet);
1160 *data |= (packet.data << 16);
1161 break;
1162 case 3:
1163 packet.header = (type << 6) | 0x0008;
1164 ret = sisusb_send_packet(sisusb, 6, &packet);
1165 *data = packet.data >> 24;
1166 packet.header = (type << 6) | 0x0007;
1167 packet.address = (addr & ~3) + 4;
1168 ret |= sisusb_send_packet(sisusb, 6, &packet);
1169 *data |= (packet.data << 8);
1170 }
1171
1172 return ret;
1173 }
1174
1175 static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
1176 char *kernbuffer, int length,
1177 char __user *userbuffer, ssize_t *bytes_read)
1178 {
1179 int ret = 0;
1180 char buf[4];
1181 u16 swap16;
1182 u32 swap32;
1183
1184 (*bytes_read = 0);
1185
1186 length &= 0x00ffffff;
1187
1188 while (length) {
1189
1190 switch (length) {
1191
1192 case 1:
1193
1194 ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM,
1195 addr, &buf[0]);
1196 if (!ret) {
1197 (*bytes_read)++;
1198 if (userbuffer) {
1199 if (put_user(buf[0],
1200 (u8 __user *)userbuffer)) {
1201 return -EFAULT;
1202 }
1203 } else {
1204 kernbuffer[0] = buf[0];
1205 }
1206 }
1207 return ret;
1208
1209 case 2:
1210 ret |= sisusb_read_memio_word(sisusb, SISUSB_TYPE_MEM,
1211 addr, &swap16);
1212 if (!ret) {
1213 (*bytes_read) += 2;
1214 if (userbuffer) {
1215 if (put_user(swap16,
1216 (u16 __user *)userbuffer))
1217 return -EFAULT;
1218 } else {
1219 *((u16 *)kernbuffer) = swap16;
1220 }
1221 }
1222 return ret;
1223
1224 case 3:
1225 ret |= sisusb_read_memio_24bit(sisusb, SISUSB_TYPE_MEM,
1226 addr, &swap32);
1227 if (!ret) {
1228 (*bytes_read) += 3;
1229 #ifdef __BIG_ENDIAN
1230 buf[0] = (swap32 >> 16) & 0xff;
1231 buf[1] = (swap32 >> 8) & 0xff;
1232 buf[2] = swap32 & 0xff;
1233 #else
1234 buf[2] = (swap32 >> 16) & 0xff;
1235 buf[1] = (swap32 >> 8) & 0xff;
1236 buf[0] = swap32 & 0xff;
1237 #endif
1238 if (userbuffer) {
1239 if (copy_to_user(userbuffer, &buf[0], 3))
1240 return -EFAULT;
1241 } else {
1242 kernbuffer[0] = buf[0];
1243 kernbuffer[1] = buf[1];
1244 kernbuffer[2] = buf[2];
1245 }
1246 }
1247 return ret;
1248
1249 default:
1250 ret |= sisusb_read_memio_long(sisusb, SISUSB_TYPE_MEM,
1251 addr, &swap32);
1252 if (!ret) {
1253 (*bytes_read) += 4;
1254 if (userbuffer) {
1255 if (put_user(swap32,
1256 (u32 __user *)userbuffer))
1257 return -EFAULT;
1258
1259 userbuffer += 4;
1260 } else {
1261 *((u32 *)kernbuffer) = swap32;
1262 kernbuffer += 4;
1263 }
1264 addr += 4;
1265 length -= 4;
1266 }
1267 #if 0 /* That does not work, as EP 2 is an OUT EP! */
1268 default:
1269 CLEARPACKET(&packet);
1270 packet.header = 0x001f;
1271 packet.address = 0x000001a0;
1272 packet.data = 0x00000006;
1273 ret |= sisusb_send_bridge_packet(sisusb, 10,
1274 &packet, 0);
1275 packet.header = 0x001f;
1276 packet.address = 0x000001b0;
1277 packet.data = (length & ~3) | 0x40000000;
1278 ret |= sisusb_send_bridge_packet(sisusb, 10,
1279 &packet, 0);
1280 packet.header = 0x001f;
1281 packet.address = 0x000001b4;
1282 packet.data = addr;
1283 ret |= sisusb_send_bridge_packet(sisusb, 10,
1284 &packet, 0);
1285 packet.header = 0x001f;
1286 packet.address = 0x000001a4;
1287 packet.data = 0x00000001;
1288 ret |= sisusb_send_bridge_packet(sisusb, 10,
1289 &packet, 0);
1290 if (userbuffer) {
1291 ret |= sisusb_recv_bulk_msg(sisusb,
1292 SISUSB_EP_GFX_BULK_IN,
1293 (length & ~3),
1294 NULL, userbuffer,
1295 bytes_read, 0);
1296 if (!ret) userbuffer += (*bytes_read);
1297 } else {
1298 ret |= sisusb_recv_bulk_msg(sisusb,
1299 SISUSB_EP_GFX_BULK_IN,
1300 (length & ~3),
1301 kernbuffer, NULL,
1302 bytes_read, 0);
1303 if (!ret) kernbuffer += (*bytes_read);
1304 }
1305 addr += (*bytes_read);
1306 length -= (*bytes_read);
1307 #endif
1308 }
1309
1310 if (ret)
1311 break;
1312 }
1313
1314 return ret;
1315 }
1316
1317 /* High level: Gfx (indexed) register access */
1318
1319 #ifdef INCL_SISUSB_CON
1320 int
1321 sisusb_setreg(struct sisusb_usb_data *sisusb, int port, u8 data)
1322 {
1323 return sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, data);
1324 }
1325
1326 int
1327 sisusb_getreg(struct sisusb_usb_data *sisusb, int port, u8 *data)
1328 {
1329 return sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port, data);
1330 }
1331 #endif
1332
1333 int
1334 sisusb_setidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 data)
1335 {
1336 int ret;
1337 ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, index);
1338 ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, data);
1339 return ret;
1340 }
1341
1342 int
1343 sisusb_getidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 *data)
1344 {
1345 int ret;
1346 ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, index);
1347 ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, data);
1348 return ret;
1349 }
1350
1351 int
1352 sisusb_setidxregandor(struct sisusb_usb_data *sisusb, int port, u8 idx,
1353 u8 myand, u8 myor)
1354 {
1355 int ret;
1356 u8 tmp;
1357
1358 ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, idx);
1359 ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, &tmp);
1360 tmp &= myand;
1361 tmp |= myor;
1362 ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, tmp);
1363 return ret;
1364 }
1365
1366 static int
1367 sisusb_setidxregmask(struct sisusb_usb_data *sisusb, int port, u8 idx,
1368 u8 data, u8 mask)
1369 {
1370 int ret;
1371 u8 tmp;
1372 ret = sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, idx);
1373 ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, &tmp);
1374 tmp &= ~(mask);
1375 tmp |= (data & mask);
1376 ret |= sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port + 1, tmp);
1377 return ret;
1378 }
1379
1380 int
1381 sisusb_setidxregor(struct sisusb_usb_data *sisusb, int port, u8 index, u8 myor)
1382 {
1383 return(sisusb_setidxregandor(sisusb, port, index, 0xff, myor));
1384 }
1385
1386 int
1387 sisusb_setidxregand(struct sisusb_usb_data *sisusb, int port, u8 idx, u8 myand)
1388 {
1389 return(sisusb_setidxregandor(sisusb, port, idx, myand, 0x00));
1390 }
1391
1392 /* Write/read video ram */
1393
1394 #ifdef INCL_SISUSB_CON
1395 int
1396 sisusb_writeb(struct sisusb_usb_data *sisusb, u32 adr, u8 data)
1397 {
1398 return(sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM, adr, data));
1399 }
1400
1401 int
1402 sisusb_readb(struct sisusb_usb_data *sisusb, u32 adr, u8 *data)
1403 {
1404 return(sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, adr, data));
1405 }
1406
1407 #if 0
1408
1409 int
1410 sisusb_writew(struct sisusb_usb_data *sisusb, u32 adr, u16 data)
1411 {
1412 return(sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM, adr, data));
1413 }
1414
1415 int
1416 sisusb_readw(struct sisusb_usb_data *sisusb, u32 adr, u16 *data)
1417 {
1418 return(sisusb_read_memio_word(sisusb, SISUSB_TYPE_MEM, adr, data));
1419 }
1420
1421 #endif /* 0 */
1422
1423 int
1424 sisusb_copy_memory(struct sisusb_usb_data *sisusb, char *src,
1425 u32 dest, int length, size_t *bytes_written)
1426 {
1427 return(sisusb_write_mem_bulk(sisusb, dest, src, length, NULL, 0, bytes_written));
1428 }
1429
1430 #ifdef SISUSBENDIANTEST
1431 int
1432 sisusb_read_memory(struct sisusb_usb_data *sisusb, char *dest,
1433 u32 src, int length, size_t *bytes_written)
1434 {
1435 return(sisusb_read_mem_bulk(sisusb, src, dest, length, NULL, bytes_written));
1436 }
1437 #endif
1438 #endif
1439
1440 #ifdef SISUSBENDIANTEST
1441 static void
1442 sisusb_testreadwrite(struct sisusb_usb_data *sisusb)
1443 {
1444 static char srcbuffer[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
1445 char destbuffer[10];
1446 size_t dummy;
1447 int i,j;
1448
1449 sisusb_copy_memory(sisusb, srcbuffer, sisusb->vrambase, 7, &dummy);
1450
1451 for(i = 1; i <= 7; i++) {
1452 printk(KERN_DEBUG "sisusb: rwtest %d bytes\n", i);
1453 sisusb_read_memory(sisusb, destbuffer, sisusb->vrambase, i, &dummy);
1454 for(j = 0; j < i; j++) {
1455 printk(KERN_DEBUG "sisusb: rwtest read[%d] = %x\n", j, destbuffer[j]);
1456 }
1457 }
1458 }
1459 #endif
1460
1461 /* access pci config registers (reg numbers 0, 4, 8, etc) */
1462
1463 static int
1464 sisusb_write_pci_config(struct sisusb_usb_data *sisusb, int regnum, u32 data)
1465 {
1466 struct sisusb_packet packet;
1467 int ret;
1468
1469 packet.header = 0x008f;
1470 packet.address = regnum | 0x10000;
1471 packet.data = data;
1472 ret = sisusb_send_packet(sisusb, 10, &packet);
1473 return ret;
1474 }
1475
1476 static int
1477 sisusb_read_pci_config(struct sisusb_usb_data *sisusb, int regnum, u32 *data)
1478 {
1479 struct sisusb_packet packet;
1480 int ret;
1481
1482 packet.header = 0x008f;
1483 packet.address = (u32)regnum | 0x10000;
1484 ret = sisusb_send_packet(sisusb, 6, &packet);
1485 *data = packet.data;
1486 return ret;
1487 }
1488
1489 /* Clear video RAM */
1490
1491 static int
1492 sisusb_clear_vram(struct sisusb_usb_data *sisusb, u32 address, int length)
1493 {
1494 int ret, i;
1495 ssize_t j;
1496
1497 if (address < sisusb->vrambase)
1498 return 1;
1499
1500 if (address >= sisusb->vrambase + sisusb->vramsize)
1501 return 1;
1502
1503 if (address + length > sisusb->vrambase + sisusb->vramsize)
1504 length = sisusb->vrambase + sisusb->vramsize - address;
1505
1506 if (length <= 0)
1507 return 0;
1508
1509 /* allocate free buffer/urb and clear the buffer */
1510 if ((i = sisusb_alloc_outbuf(sisusb)) < 0)
1511 return -EBUSY;
1512
1513 memset(sisusb->obuf[i], 0, sisusb->obufsize);
1514
1515 /* We can write a length > buffer size here. The buffer
1516 * data will simply be re-used (like a ring-buffer).
1517 */
1518 ret = sisusb_write_mem_bulk(sisusb, address, NULL, length, NULL, i, &j);
1519
1520 /* Free the buffer/urb */
1521 sisusb_free_outbuf(sisusb, i);
1522
1523 return ret;
1524 }
1525
1526 /* Initialize the graphics core (return 0 on success)
1527 * This resets the graphics hardware and puts it into
1528 * a defined mode (640x480@60Hz)
1529 */
1530
1531 #define GETREG(r,d) sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, r, d)
1532 #define SETREG(r,d) sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, r, d)
1533 #define SETIREG(r,i,d) sisusb_setidxreg(sisusb, r, i, d)
1534 #define GETIREG(r,i,d) sisusb_getidxreg(sisusb, r, i, d)
1535 #define SETIREGOR(r,i,o) sisusb_setidxregor(sisusb, r, i, o)
1536 #define SETIREGAND(r,i,a) sisusb_setidxregand(sisusb, r, i, a)
1537 #define SETIREGANDOR(r,i,a,o) sisusb_setidxregandor(sisusb, r, i, a, o)
1538 #define READL(a,d) sisusb_read_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
1539 #define WRITEL(a,d) sisusb_write_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
1540 #define READB(a,d) sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
1541 #define WRITEB(a,d) sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
1542
1543 static int
1544 sisusb_triggersr16(struct sisusb_usb_data *sisusb, u8 ramtype)
1545 {
1546 int ret;
1547 u8 tmp8;
1548
1549 ret = GETIREG(SISSR, 0x16, &tmp8);
1550 if (ramtype <= 1) {
1551 tmp8 &= 0x3f;
1552 ret |= SETIREG(SISSR, 0x16, tmp8);
1553 tmp8 |= 0x80;
1554 ret |= SETIREG(SISSR, 0x16, tmp8);
1555 } else {
1556 tmp8 |= 0xc0;
1557 ret |= SETIREG(SISSR, 0x16, tmp8);
1558 tmp8 &= 0x0f;
1559 ret |= SETIREG(SISSR, 0x16, tmp8);
1560 tmp8 |= 0x80;
1561 ret |= SETIREG(SISSR, 0x16, tmp8);
1562 tmp8 &= 0x0f;
1563 ret |= SETIREG(SISSR, 0x16, tmp8);
1564 tmp8 |= 0xd0;
1565 ret |= SETIREG(SISSR, 0x16, tmp8);
1566 tmp8 &= 0x0f;
1567 ret |= SETIREG(SISSR, 0x16, tmp8);
1568 tmp8 |= 0xa0;
1569 ret |= SETIREG(SISSR, 0x16, tmp8);
1570 }
1571 return ret;
1572 }
1573
1574 static int
1575 sisusb_getbuswidth(struct sisusb_usb_data *sisusb, int *bw, int *chab)
1576 {
1577 int ret;
1578 u8 ramtype, done = 0;
1579 u32 t0, t1, t2, t3;
1580 u32 ramptr = SISUSB_PCI_MEMBASE;
1581
1582 ret = GETIREG(SISSR, 0x3a, &ramtype);
1583 ramtype &= 3;
1584
1585 ret |= SETIREG(SISSR, 0x13, 0x00);
1586
1587 if (ramtype <= 1) {
1588 ret |= SETIREG(SISSR, 0x14, 0x12);
1589 ret |= SETIREGAND(SISSR, 0x15, 0xef);
1590 } else {
1591 ret |= SETIREG(SISSR, 0x14, 0x02);
1592 }
1593
1594 ret |= sisusb_triggersr16(sisusb, ramtype);
1595 ret |= WRITEL(ramptr + 0, 0x01234567);
1596 ret |= WRITEL(ramptr + 4, 0x456789ab);
1597 ret |= WRITEL(ramptr + 8, 0x89abcdef);
1598 ret |= WRITEL(ramptr + 12, 0xcdef0123);
1599 ret |= WRITEL(ramptr + 16, 0x55555555);
1600 ret |= WRITEL(ramptr + 20, 0x55555555);
1601 ret |= WRITEL(ramptr + 24, 0xffffffff);
1602 ret |= WRITEL(ramptr + 28, 0xffffffff);
1603 ret |= READL(ramptr + 0, &t0);
1604 ret |= READL(ramptr + 4, &t1);
1605 ret |= READL(ramptr + 8, &t2);
1606 ret |= READL(ramptr + 12, &t3);
1607
1608 if (ramtype <= 1) {
1609
1610 *chab = 0; *bw = 64;
1611
1612 if ((t3 != 0xcdef0123) || (t2 != 0x89abcdef)) {
1613 if ((t1 == 0x456789ab) && (t0 == 0x01234567)) {
1614 *chab = 0; *bw = 64;
1615 ret |= SETIREGAND(SISSR, 0x14, 0xfd);
1616 }
1617 }
1618 if ((t1 != 0x456789ab) || (t0 != 0x01234567)) {
1619 *chab = 1; *bw = 64;
1620 ret |= SETIREGANDOR(SISSR, 0x14, 0xfc,0x01);
1621
1622 ret |= sisusb_triggersr16(sisusb, ramtype);
1623 ret |= WRITEL(ramptr + 0, 0x89abcdef);
1624 ret |= WRITEL(ramptr + 4, 0xcdef0123);
1625 ret |= WRITEL(ramptr + 8, 0x55555555);
1626 ret |= WRITEL(ramptr + 12, 0x55555555);
1627 ret |= WRITEL(ramptr + 16, 0xaaaaaaaa);
1628 ret |= WRITEL(ramptr + 20, 0xaaaaaaaa);
1629 ret |= READL(ramptr + 4, &t1);
1630
1631 if (t1 != 0xcdef0123) {
1632 *bw = 32;
1633 ret |= SETIREGOR(SISSR, 0x15, 0x10);
1634 }
1635 }
1636
1637 } else {
1638
1639 *chab = 0; *bw = 64; /* default: cha, bw = 64 */
1640
1641 done = 0;
1642
1643 if (t1 == 0x456789ab) {
1644 if (t0 == 0x01234567) {
1645 *chab = 0; *bw = 64;
1646 done = 1;
1647 }
1648 } else {
1649 if (t0 == 0x01234567) {
1650 *chab = 0; *bw = 32;
1651 ret |= SETIREG(SISSR, 0x14, 0x00);
1652 done = 1;
1653 }
1654 }
1655
1656 if (!done) {
1657 ret |= SETIREG(SISSR, 0x14, 0x03);
1658 ret |= sisusb_triggersr16(sisusb, ramtype);
1659
1660 ret |= WRITEL(ramptr + 0, 0x01234567);
1661 ret |= WRITEL(ramptr + 4, 0x456789ab);
1662 ret |= WRITEL(ramptr + 8, 0x89abcdef);
1663 ret |= WRITEL(ramptr + 12, 0xcdef0123);
1664 ret |= WRITEL(ramptr + 16, 0x55555555);
1665 ret |= WRITEL(ramptr + 20, 0x55555555);
1666 ret |= WRITEL(ramptr + 24, 0xffffffff);
1667 ret |= WRITEL(ramptr + 28, 0xffffffff);
1668 ret |= READL(ramptr + 0, &t0);
1669 ret |= READL(ramptr + 4, &t1);
1670
1671 if (t1 == 0x456789ab) {
1672 if (t0 == 0x01234567) {
1673 *chab = 1; *bw = 64;
1674 return ret;
1675 } /* else error */
1676 } else {
1677 if (t0 == 0x01234567) {
1678 *chab = 1; *bw = 32;
1679 ret |= SETIREG(SISSR, 0x14, 0x01);
1680 } /* else error */
1681 }
1682 }
1683 }
1684 return ret;
1685 }
1686
1687 static int
1688 sisusb_verify_mclk(struct sisusb_usb_data *sisusb)
1689 {
1690 int ret = 0;
1691 u32 ramptr = SISUSB_PCI_MEMBASE;
1692 u8 tmp1, tmp2, i, j;
1693
1694 ret |= WRITEB(ramptr, 0xaa);
1695 ret |= WRITEB(ramptr + 16, 0x55);
1696 ret |= READB(ramptr, &tmp1);
1697 ret |= READB(ramptr + 16, &tmp2);
1698 if ((tmp1 != 0xaa) || (tmp2 != 0x55)) {
1699 for (i = 0, j = 16; i < 2; i++, j += 16) {
1700 ret |= GETIREG(SISSR, 0x21, &tmp1);
1701 ret |= SETIREGAND(SISSR, 0x21, (tmp1 & 0xfb));
1702 ret |= SETIREGOR(SISSR, 0x3c, 0x01); /* not on 330 */
1703 ret |= SETIREGAND(SISSR, 0x3c, 0xfe); /* not on 330 */
1704 ret |= SETIREG(SISSR, 0x21, tmp1);
1705 ret |= WRITEB(ramptr + 16 + j, j);
1706 ret |= READB(ramptr + 16 + j, &tmp1);
1707 if (tmp1 == j) {
1708 ret |= WRITEB(ramptr + j, j);
1709 break;
1710 }
1711 }
1712 }
1713 return ret;
1714 }
1715
1716 static int
1717 sisusb_set_rank(struct sisusb_usb_data *sisusb, int *iret, int index,
1718 u8 rankno, u8 chab, const u8 dramtype[][5],
1719 int bw)
1720 {
1721 int ret = 0, ranksize;
1722 u8 tmp;
1723
1724 *iret = 0;
1725
1726 if ((rankno == 2) && (dramtype[index][0] == 2))
1727 return ret;
1728
1729 ranksize = dramtype[index][3] / 2 * bw / 32;
1730
1731 if ((ranksize * rankno) > 128)
1732 return ret;
1733
1734 tmp = 0;
1735 while ((ranksize >>= 1) > 0) tmp += 0x10;
1736 tmp |= ((rankno - 1) << 2);
1737 tmp |= ((bw / 64) & 0x02);
1738 tmp |= (chab & 0x01);
1739
1740 ret = SETIREG(SISSR, 0x14, tmp);
1741 ret |= sisusb_triggersr16(sisusb, 0); /* sic! */
1742
1743 *iret = 1;
1744
1745 return ret;
1746 }
1747
1748 static int
1749 sisusb_check_rbc(struct sisusb_usb_data *sisusb, int *iret, u32 inc, int testn)
1750 {
1751 int ret = 0, i;
1752 u32 j, tmp;
1753
1754 *iret = 0;
1755
1756 for (i = 0, j = 0; i < testn; i++) {
1757 ret |= WRITEL(sisusb->vrambase + j, j);
1758 j += inc;
1759 }
1760
1761 for (i = 0, j = 0; i < testn; i++) {
1762 ret |= READL(sisusb->vrambase + j, &tmp);
1763 if (tmp != j) return ret;
1764 j += inc;
1765 }
1766
1767 *iret = 1;
1768 return ret;
1769 }
1770
1771 static int
1772 sisusb_check_ranks(struct sisusb_usb_data *sisusb, int *iret, int rankno,
1773 int idx, int bw, const u8 rtype[][5])
1774 {
1775 int ret = 0, i, i2ret;
1776 u32 inc;
1777
1778 *iret = 0;
1779
1780 for (i = rankno; i >= 1; i--) {
1781 inc = 1 << (rtype[idx][2] +
1782 rtype[idx][1] +
1783 rtype[idx][0] +
1784 bw / 64 + i);
1785 ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 2);
1786 if (!i2ret)
1787 return ret;
1788 }
1789
1790 inc = 1 << (rtype[idx][2] + bw / 64 + 2);
1791 ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 4);
1792 if (!i2ret)
1793 return ret;
1794
1795 inc = 1 << (10 + bw / 64);
1796 ret |= sisusb_check_rbc(sisusb, &i2ret, inc, 2);
1797 if (!i2ret)
1798 return ret;
1799
1800 *iret = 1;
1801 return ret;
1802 }
1803
1804 static int
1805 sisusb_get_sdram_size(struct sisusb_usb_data *sisusb, int *iret, int bw,
1806 int chab)
1807 {
1808 int ret = 0, i2ret = 0, i, j;
1809 static const u8 sdramtype[13][5] = {
1810 { 2, 12, 9, 64, 0x35 },
1811 { 1, 13, 9, 64, 0x44 },
1812 { 2, 12, 8, 32, 0x31 },
1813 { 2, 11, 9, 32, 0x25 },
1814 { 1, 12, 9, 32, 0x34 },
1815 { 1, 13, 8, 32, 0x40 },
1816 { 2, 11, 8, 16, 0x21 },
1817 { 1, 12, 8, 16, 0x30 },
1818 { 1, 11, 9, 16, 0x24 },
1819 { 1, 11, 8, 8, 0x20 },
1820 { 2, 9, 8, 4, 0x01 },
1821 { 1, 10, 8, 4, 0x10 },
1822 { 1, 9, 8, 2, 0x00 }
1823 };
1824
1825 *iret = 1; /* error */
1826
1827 for (i = 0; i < 13; i++) {
1828 ret |= SETIREGANDOR(SISSR, 0x13, 0x80, sdramtype[i][4]);
1829 for (j = 2; j > 0; j--) {
1830 ret |= sisusb_set_rank(sisusb, &i2ret, i, j,
1831 chab, sdramtype, bw);
1832 if (!i2ret)
1833 continue;
1834
1835 ret |= sisusb_check_ranks(sisusb, &i2ret, j, i,
1836 bw, sdramtype);
1837 if (i2ret) {
1838 *iret = 0; /* ram size found */
1839 return ret;
1840 }
1841 }
1842 }
1843
1844 return ret;
1845 }
1846
1847 static int
1848 sisusb_setup_screen(struct sisusb_usb_data *sisusb, int clrall, int drwfr)
1849 {
1850 int ret = 0;
1851 u32 address;
1852 int i, length, modex, modey, bpp;
1853
1854 modex = 640; modey = 480; bpp = 2;
1855
1856 address = sisusb->vrambase; /* Clear video ram */
1857
1858 if (clrall)
1859 length = sisusb->vramsize;
1860 else
1861 length = modex * bpp * modey;
1862
1863 ret = sisusb_clear_vram(sisusb, address, length);
1864
1865 if (!ret && drwfr) {
1866 for (i = 0; i < modex; i++) {
1867 address = sisusb->vrambase + (i * bpp);
1868 ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
1869 address, 0xf100);
1870 address += (modex * (modey-1) * bpp);
1871 ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
1872 address, 0xf100);
1873 }
1874 for (i = 0; i < modey; i++) {
1875 address = sisusb->vrambase + ((i * modex) * bpp);
1876 ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
1877 address, 0xf100);
1878 address += ((modex - 1) * bpp);
1879 ret |= sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM,
1880 address, 0xf100);
1881 }
1882 }
1883
1884 return ret;
1885 }
1886
1887 static int
1888 sisusb_set_default_mode(struct sisusb_usb_data *sisusb, int touchengines)
1889 {
1890 int ret = 0, i, j, modex, modey, bpp, du;
1891 u8 sr31, cr63, tmp8;
1892 static const char attrdata[] = {
1893 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
1894 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
1895 0x01,0x00,0x00,0x00
1896 };
1897 static const char crtcrdata[] = {
1898 0x5f,0x4f,0x50,0x82,0x54,0x80,0x0b,0x3e,
1899 0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,
1900 0xea,0x8c,0xdf,0x28,0x40,0xe7,0x04,0xa3,
1901 0xff
1902 };
1903 static const char grcdata[] = {
1904 0x00,0x00,0x00,0x00,0x00,0x40,0x05,0x0f,
1905 0xff
1906 };
1907 static const char crtcdata[] = {
1908 0x5f,0x4f,0x4f,0x83,0x55,0x81,0x0b,0x3e,
1909 0xe9,0x8b,0xdf,0xe8,0x0c,0x00,0x00,0x05,
1910 0x00
1911 };
1912
1913 modex = 640; modey = 480; bpp = 2;
1914
1915 GETIREG(SISSR, 0x31, &sr31);
1916 GETIREG(SISCR, 0x63, &cr63);
1917 SETIREGOR(SISSR, 0x01, 0x20);
1918 SETIREG(SISCR, 0x63, cr63 & 0xbf);
1919 SETIREGOR(SISCR, 0x17, 0x80);
1920 SETIREGOR(SISSR, 0x1f, 0x04);
1921 SETIREGAND(SISSR, 0x07, 0xfb);
1922 SETIREG(SISSR, 0x00, 0x03); /* seq */
1923 SETIREG(SISSR, 0x01, 0x21);
1924 SETIREG(SISSR, 0x02, 0x0f);
1925 SETIREG(SISSR, 0x03, 0x00);
1926 SETIREG(SISSR, 0x04, 0x0e);
1927 SETREG(SISMISCW, 0x23); /* misc */
1928 for (i = 0; i <= 0x18; i++) { /* crtc */
1929 SETIREG(SISCR, i, crtcrdata[i]);
1930 }
1931 for (i = 0; i <= 0x13; i++) { /* att */
1932 GETREG(SISINPSTAT, &tmp8);
1933 SETREG(SISAR, i);
1934 SETREG(SISAR, attrdata[i]);
1935 }
1936 GETREG(SISINPSTAT, &tmp8);
1937 SETREG(SISAR, 0x14);
1938 SETREG(SISAR, 0x00);
1939 GETREG(SISINPSTAT, &tmp8);
1940 SETREG(SISAR, 0x20);
1941 GETREG(SISINPSTAT, &tmp8);
1942 for (i = 0; i <= 0x08; i++) { /* grc */
1943 SETIREG(SISGR, i, grcdata[i]);
1944 }
1945 SETIREGAND(SISGR, 0x05, 0xbf);
1946 for (i = 0x0A; i <= 0x0E; i++) { /* clr ext */
1947 SETIREG(SISSR, i, 0x00);
1948 }
1949 SETIREGAND(SISSR, 0x37, 0xfe);
1950 SETREG(SISMISCW, 0xef); /* sync */
1951 SETIREG(SISCR, 0x11, 0x00); /* crtc */
1952 for (j = 0x00, i = 0; i <= 7; i++, j++) {
1953 SETIREG(SISCR, j, crtcdata[i]);
1954 }
1955 for (j = 0x10; i <= 10; i++, j++) {
1956 SETIREG(SISCR, j, crtcdata[i]);
1957 }
1958 for (j = 0x15; i <= 12; i++, j++) {
1959 SETIREG(SISCR, j, crtcdata[i]);
1960 }
1961 for (j = 0x0A; i <= 15; i++, j++) {
1962 SETIREG(SISSR, j, crtcdata[i]);
1963 }
1964 SETIREG(SISSR, 0x0E, (crtcdata[16] & 0xE0));
1965 SETIREGANDOR(SISCR, 0x09, 0x5f, ((crtcdata[16] & 0x01) << 5));
1966 SETIREG(SISCR, 0x14, 0x4f);
1967 du = (modex / 16) * (bpp * 2); /* offset/pitch */
1968 if (modex % 16) du += bpp;
1969 SETIREGANDOR(SISSR, 0x0e, 0xf0, ((du >> 8) & 0x0f));
1970 SETIREG(SISCR, 0x13, (du & 0xff));
1971 du <<= 5;
1972 tmp8 = du >> 8;
1973 if (du & 0xff) tmp8++;
1974 SETIREG(SISSR, 0x10, tmp8);
1975 SETIREG(SISSR, 0x31, 0x00); /* VCLK */
1976 SETIREG(SISSR, 0x2b, 0x1b);
1977 SETIREG(SISSR, 0x2c, 0xe1);
1978 SETIREG(SISSR, 0x2d, 0x01);
1979 SETIREGAND(SISSR, 0x3d, 0xfe); /* FIFO */
1980 SETIREG(SISSR, 0x08, 0xae);
1981 SETIREGAND(SISSR, 0x09, 0xf0);
1982 SETIREG(SISSR, 0x08, 0x34);
1983 SETIREGOR(SISSR, 0x3d, 0x01);
1984 SETIREGAND(SISSR, 0x1f, 0x3f); /* mode regs */
1985 SETIREGANDOR(SISSR, 0x06, 0xc0, 0x0a);
1986 SETIREG(SISCR, 0x19, 0x00);
1987 SETIREGAND(SISCR, 0x1a, 0xfc);
1988 SETIREGAND(SISSR, 0x0f, 0xb7);
1989 SETIREGAND(SISSR, 0x31, 0xfb);
1990 SETIREGANDOR(SISSR, 0x21, 0x1f, 0xa0);
1991 SETIREGAND(SISSR, 0x32, 0xf3);
1992 SETIREGANDOR(SISSR, 0x07, 0xf8, 0x03);
1993 SETIREG(SISCR, 0x52, 0x6c);
1994
1995 SETIREG(SISCR, 0x0d, 0x00); /* adjust frame */
1996 SETIREG(SISCR, 0x0c, 0x00);
1997 SETIREG(SISSR, 0x0d, 0x00);
1998 SETIREGAND(SISSR, 0x37, 0xfe);
1999
2000 SETIREG(SISCR, 0x32, 0x20);
2001 SETIREGAND(SISSR, 0x01, 0xdf); /* enable display */
2002 SETIREG(SISCR, 0x63, (cr63 & 0xbf));
2003 SETIREG(SISSR, 0x31, (sr31 & 0xfb));
2004
2005 if (touchengines) {
2006 SETIREG(SISSR, 0x20, 0xa1); /* enable engines */
2007 SETIREGOR(SISSR, 0x1e, 0x5a);
2008
2009 SETIREG(SISSR, 0x26, 0x01); /* disable cmdqueue */
2010 SETIREG(SISSR, 0x27, 0x1f);
2011 SETIREG(SISSR, 0x26, 0x00);
2012 }
2013
2014 SETIREG(SISCR, 0x34, 0x44); /* we just set std mode #44 */
2015
2016 return ret;
2017 }
2018
2019 static int
2020 sisusb_init_gfxcore(struct sisusb_usb_data *sisusb)
2021 {
2022 int ret = 0, i, j, bw, chab, iret, retry = 3;
2023 u8 tmp8, ramtype;
2024 u32 tmp32;
2025 static const char mclktable[] = {
2026 0x3b, 0x22, 0x01, 143,
2027 0x3b, 0x22, 0x01, 143,
2028 0x3b, 0x22, 0x01, 143,
2029 0x3b, 0x22, 0x01, 143
2030 };
2031 static const char eclktable[] = {
2032 0x3b, 0x22, 0x01, 143,
2033 0x3b, 0x22, 0x01, 143,
2034 0x3b, 0x22, 0x01, 143,
2035 0x3b, 0x22, 0x01, 143
2036 };
2037 static const char ramtypetable1[] = {
2038 0x00, 0x04, 0x60, 0x60,
2039 0x0f, 0x0f, 0x1f, 0x1f,
2040 0xba, 0xba, 0xba, 0xba,
2041 0xa9, 0xa9, 0xac, 0xac,
2042 0xa0, 0xa0, 0xa0, 0xa8,
2043 0x00, 0x00, 0x02, 0x02,
2044 0x30, 0x30, 0x40, 0x40
2045 };
2046 static const char ramtypetable2[] = {
2047 0x77, 0x77, 0x44, 0x44,
2048 0x77, 0x77, 0x44, 0x44,
2049 0x00, 0x00, 0x00, 0x00,
2050 0x5b, 0x5b, 0xab, 0xab,
2051 0x00, 0x00, 0xf0, 0xf8
2052 };
2053
2054 while (retry--) {
2055
2056 /* Enable VGA */
2057 ret = GETREG(SISVGAEN, &tmp8);
2058 ret |= SETREG(SISVGAEN, (tmp8 | 0x01));
2059
2060 /* Enable GPU access to VRAM */
2061 ret |= GETREG(SISMISCR, &tmp8);
2062 ret |= SETREG(SISMISCW, (tmp8 | 0x01));
2063
2064 if (ret) continue;
2065
2066 /* Reset registers */
2067 ret |= SETIREGAND(SISCR, 0x5b, 0xdf);
2068 ret |= SETIREG(SISSR, 0x05, 0x86);
2069 ret |= SETIREGOR(SISSR, 0x20, 0x01);
2070
2071 ret |= SETREG(SISMISCW, 0x67);
2072
2073 for (i = 0x06; i <= 0x1f; i++) {
2074 ret |= SETIREG(SISSR, i, 0x00);
2075 }
2076 for (i = 0x21; i <= 0x27; i++) {
2077 ret |= SETIREG(SISSR, i, 0x00);
2078 }
2079 for (i = 0x31; i <= 0x3d; i++) {
2080 ret |= SETIREG(SISSR, i, 0x00);
2081 }
2082 for (i = 0x12; i <= 0x1b; i++) {
2083 ret |= SETIREG(SISSR, i, 0x00);
2084 }
2085 for (i = 0x79; i <= 0x7c; i++) {
2086 ret |= SETIREG(SISCR, i, 0x00);
2087 }
2088
2089 if (ret) continue;
2090
2091 ret |= SETIREG(SISCR, 0x63, 0x80);
2092
2093 ret |= GETIREG(SISSR, 0x3a, &ramtype);
2094 ramtype &= 0x03;
2095
2096 ret |= SETIREG(SISSR, 0x28, mclktable[ramtype * 4]);
2097 ret |= SETIREG(SISSR, 0x29, mclktable[(ramtype * 4) + 1]);
2098 ret |= SETIREG(SISSR, 0x2a, mclktable[(ramtype * 4) + 2]);
2099
2100 ret |= SETIREG(SISSR, 0x2e, eclktable[ramtype * 4]);
2101 ret |= SETIREG(SISSR, 0x2f, eclktable[(ramtype * 4) + 1]);
2102 ret |= SETIREG(SISSR, 0x30, eclktable[(ramtype * 4) + 2]);
2103
2104 ret |= SETIREG(SISSR, 0x07, 0x18);
2105 ret |= SETIREG(SISSR, 0x11, 0x0f);
2106
2107 if (ret) continue;
2108
2109 for (i = 0x15, j = 0; i <= 0x1b; i++, j++) {
2110 ret |= SETIREG(SISSR, i, ramtypetable1[(j*4) + ramtype]);
2111 }
2112 for (i = 0x40, j = 0; i <= 0x44; i++, j++) {
2113 ret |= SETIREG(SISCR, i, ramtypetable2[(j*4) + ramtype]);
2114 }
2115
2116 ret |= SETIREG(SISCR, 0x49, 0xaa);
2117
2118 ret |= SETIREG(SISSR, 0x1f, 0x00);
2119 ret |= SETIREG(SISSR, 0x20, 0xa0);
2120 ret |= SETIREG(SISSR, 0x23, 0xf6);
2121 ret |= SETIREG(SISSR, 0x24, 0x0d);
2122 ret |= SETIREG(SISSR, 0x25, 0x33);
2123
2124 ret |= SETIREG(SISSR, 0x11, 0x0f);
2125
2126 ret |= SETIREGOR(SISPART1, 0x2f, 0x01);
2127
2128 ret |= SETIREGAND(SISCAP, 0x3f, 0xef);
2129
2130 if (ret) continue;
2131
2132 ret |= SETIREG(SISPART1, 0x00, 0x00);
2133
2134 ret |= GETIREG(SISSR, 0x13, &tmp8);
2135 tmp8 >>= 4;
2136
2137 ret |= SETIREG(SISPART1, 0x02, 0x00);
2138 ret |= SETIREG(SISPART1, 0x2e, 0x08);
2139
2140 ret |= sisusb_read_pci_config(sisusb, 0x50, &tmp32);
2141 tmp32 &= 0x00f00000;
2142 tmp8 = (tmp32 == 0x100000) ? 0x33 : 0x03;
2143 ret |= SETIREG(SISSR, 0x25, tmp8);
2144 tmp8 = (tmp32 == 0x100000) ? 0xaa : 0x88;
2145 ret |= SETIREG(SISCR, 0x49, tmp8);
2146
2147 ret |= SETIREG(SISSR, 0x27, 0x1f);
2148 ret |= SETIREG(SISSR, 0x31, 0x00);
2149 ret |= SETIREG(SISSR, 0x32, 0x11);
2150 ret |= SETIREG(SISSR, 0x33, 0x00);
2151
2152 if (ret) continue;
2153
2154 ret |= SETIREG(SISCR, 0x83, 0x00);
2155
2156 ret |= sisusb_set_default_mode(sisusb, 0);
2157
2158 ret |= SETIREGAND(SISSR, 0x21, 0xdf);
2159 ret |= SETIREGOR(SISSR, 0x01, 0x20);
2160 ret |= SETIREGOR(SISSR, 0x16, 0x0f);
2161
2162 ret |= sisusb_triggersr16(sisusb, ramtype);
2163
2164 /* Disable refresh */
2165 ret |= SETIREGAND(SISSR, 0x17, 0xf8);
2166 ret |= SETIREGOR(SISSR, 0x19, 0x03);
2167
2168 ret |= sisusb_getbuswidth(sisusb, &bw, &chab);
2169 ret |= sisusb_verify_mclk(sisusb);
2170
2171 if (ramtype <= 1) {
2172 ret |= sisusb_get_sdram_size(sisusb, &iret, bw, chab);
2173 if (iret) {
2174 printk(KERN_ERR "sisusbvga[%d]: RAM size "
2175 "detection failed, "
2176 "assuming 8MB video RAM\n",
2177 sisusb->minor);
2178 ret |= SETIREG(SISSR,0x14,0x31);
2179 /* TODO */
2180 }
2181 } else {
2182 printk(KERN_ERR "sisusbvga[%d]: DDR RAM device found, "
2183 "assuming 8MB video RAM\n",
2184 sisusb->minor);
2185 ret |= SETIREG(SISSR,0x14,0x31);
2186 /* *** TODO *** */
2187 }
2188
2189 /* Enable refresh */
2190 ret |= SETIREG(SISSR, 0x16, ramtypetable1[4 + ramtype]);
2191 ret |= SETIREG(SISSR, 0x17, ramtypetable1[8 + ramtype]);
2192 ret |= SETIREG(SISSR, 0x19, ramtypetable1[16 + ramtype]);
2193
2194 ret |= SETIREGOR(SISSR, 0x21, 0x20);
2195
2196 ret |= SETIREG(SISSR, 0x22, 0xfb);
2197 ret |= SETIREG(SISSR, 0x21, 0xa5);
2198
2199 if (ret == 0)
2200 break;
2201 }
2202
2203 return ret;
2204 }
2205
2206 #undef SETREG
2207 #undef GETREG
2208 #undef SETIREG
2209 #undef GETIREG
2210 #undef SETIREGOR
2211 #undef SETIREGAND
2212 #undef SETIREGANDOR
2213 #undef READL
2214 #undef WRITEL
2215
2216 static void
2217 sisusb_get_ramconfig(struct sisusb_usb_data *sisusb)
2218 {
2219 u8 tmp8, tmp82, ramtype;
2220 int bw = 0;
2221 char *ramtypetext1 = NULL;
2222 const char *ramtypetext2[] = { "SDR SDRAM", "SDR SGRAM",
2223 "DDR SDRAM", "DDR SGRAM" };
2224 static const int busSDR[4] = {64, 64, 128, 128};
2225 static const int busDDR[4] = {32, 32, 64, 64};
2226 static const int busDDRA[4] = {64+32, 64+32 , (64+32)*2, (64+32)*2};
2227
2228 sisusb_getidxreg(sisusb, SISSR, 0x14, &tmp8);
2229 sisusb_getidxreg(sisusb, SISSR, 0x15, &tmp82);
2230 sisusb_getidxreg(sisusb, SISSR, 0x3a, &ramtype);
2231 sisusb->vramsize = (1 << ((tmp8 & 0xf0) >> 4)) * 1024 * 1024;
2232 ramtype &= 0x03;
2233 switch ((tmp8 >> 2) & 0x03) {
2234 case 0: ramtypetext1 = "1 ch/1 r";
2235 if (tmp82 & 0x10) {
2236 bw = 32;
2237 } else {
2238 bw = busSDR[(tmp8 & 0x03)];
2239 }
2240 break;
2241 case 1: ramtypetext1 = "1 ch/2 r";
2242 sisusb->vramsize <<= 1;
2243 bw = busSDR[(tmp8 & 0x03)];
2244 break;
2245 case 2: ramtypetext1 = "asymmeric";
2246 sisusb->vramsize += sisusb->vramsize/2;
2247 bw = busDDRA[(tmp8 & 0x03)];
2248 break;
2249 case 3: ramtypetext1 = "2 channel";
2250 sisusb->vramsize <<= 1;
2251 bw = busDDR[(tmp8 & 0x03)];
2252 break;
2253 }
2254
2255 printk(KERN_INFO "sisusbvga[%d]: %dMB %s %s, bus width %d\n",
2256 sisusb->minor, (sisusb->vramsize >> 20), ramtypetext1,
2257 ramtypetext2[ramtype], bw);
2258 }
2259
2260 static int
2261 sisusb_do_init_gfxdevice(struct sisusb_usb_data *sisusb)
2262 {
2263 struct sisusb_packet packet;
2264 int ret;
2265 u32 tmp32;
2266
2267 /* Do some magic */
2268 packet.header = 0x001f;
2269 packet.address = 0x00000324;
2270 packet.data = 0x00000004;
2271 ret = sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2272
2273 packet.header = 0x001f;
2274 packet.address = 0x00000364;
2275 packet.data = 0x00000004;
2276 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2277
2278 packet.header = 0x001f;
2279 packet.address = 0x00000384;
2280 packet.data = 0x00000004;
2281 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2282
2283 packet.header = 0x001f;
2284 packet.address = 0x00000100;
2285 packet.data = 0x00000700;
2286 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2287
2288 packet.header = 0x000f;
2289 packet.address = 0x00000004;
2290 ret |= sisusb_send_bridge_packet(sisusb, 6, &packet, 0);
2291 packet.data |= 0x17;
2292 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2293
2294 /* Init BAR 0 (VRAM) */
2295 ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
2296 ret |= sisusb_write_pci_config(sisusb, 0x10, 0xfffffff0);
2297 ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
2298 tmp32 &= 0x0f;
2299 tmp32 |= SISUSB_PCI_MEMBASE;
2300 ret |= sisusb_write_pci_config(sisusb, 0x10, tmp32);
2301
2302 /* Init BAR 1 (MMIO) */
2303 ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
2304 ret |= sisusb_write_pci_config(sisusb, 0x14, 0xfffffff0);
2305 ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
2306 tmp32 &= 0x0f;
2307 tmp32 |= SISUSB_PCI_MMIOBASE;
2308 ret |= sisusb_write_pci_config(sisusb, 0x14, tmp32);
2309
2310 /* Init BAR 2 (i/o ports) */
2311 ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
2312 ret |= sisusb_write_pci_config(sisusb, 0x18, 0xfffffff0);
2313 ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
2314 tmp32 &= 0x0f;
2315 tmp32 |= SISUSB_PCI_IOPORTBASE;
2316 ret |= sisusb_write_pci_config(sisusb, 0x18, tmp32);
2317
2318 /* Enable memory and i/o access */
2319 ret |= sisusb_read_pci_config(sisusb, 0x04, &tmp32);
2320 tmp32 |= 0x3;
2321 ret |= sisusb_write_pci_config(sisusb, 0x04, tmp32);
2322
2323 if (ret == 0) {
2324 /* Some further magic */
2325 packet.header = 0x001f;
2326 packet.address = 0x00000050;
2327 packet.data = 0x000000ff;
2328 ret |= sisusb_send_bridge_packet(sisusb, 10, &packet, 0);
2329 }
2330
2331 return ret;
2332 }
2333
2334 /* Initialize the graphics device (return 0 on success)
2335 * This initializes the net2280 as well as the PCI registers
2336 * of the graphics board.
2337 */
2338
2339 static int
2340 sisusb_init_gfxdevice(struct sisusb_usb_data *sisusb, int initscreen)
2341 {
2342 int ret = 0, test = 0;
2343 u32 tmp32;
2344
2345 if (sisusb->devinit == 1) {
2346 /* Read PCI BARs and see if they have been set up */
2347 ret |= sisusb_read_pci_config(sisusb, 0x10, &tmp32);
2348 if (ret) return ret;
2349 if ((tmp32 & 0xfffffff0) == SISUSB_PCI_MEMBASE) test++;
2350
2351 ret |= sisusb_read_pci_config(sisusb, 0x14, &tmp32);
2352 if (ret) return ret;
2353 if ((tmp32 & 0xfffffff0) == SISUSB_PCI_MMIOBASE) test++;
2354
2355 ret |= sisusb_read_pci_config(sisusb, 0x18, &tmp32);
2356 if (ret) return ret;
2357 if ((tmp32 & 0xfffffff0) == SISUSB_PCI_IOPORTBASE) test++;
2358 }
2359
2360 /* No? So reset the device */
2361 if ((sisusb->devinit == 0) || (test != 3)) {
2362
2363 ret |= sisusb_do_init_gfxdevice(sisusb);
2364
2365 if (ret == 0)
2366 sisusb->devinit = 1;
2367
2368 }
2369
2370 if (sisusb->devinit) {
2371 /* Initialize the graphics core */
2372 if (sisusb_init_gfxcore(sisusb) == 0) {
2373 sisusb->gfxinit = 1;
2374 sisusb_get_ramconfig(sisusb);
2375 ret |= sisusb_set_default_mode(sisusb, 1);
2376 ret |= sisusb_setup_screen(sisusb, 1, initscreen);
2377 }
2378 }
2379
2380 return ret;
2381 }
2382
2383
2384 #ifdef INCL_SISUSB_CON
2385
2386 /* Set up default text mode:
2387 - Set text mode (0x03)
2388 - Upload default font
2389 - Upload user font (if available)
2390 */
2391
2392 int
2393 sisusb_reset_text_mode(struct sisusb_usb_data *sisusb, int init)
2394 {
2395 int ret = 0, slot = sisusb->font_slot, i;
2396 const struct font_desc *myfont;
2397 u8 *tempbuf;
2398 u16 *tempbufb;
2399 size_t written;
2400 static const char bootstring[] = "SiSUSB VGA text console, (C) 2005 Thomas Winischhofer.";
2401 static const char bootlogo[] = "(o_ //\\ V_/_";
2402
2403 /* sisusb->lock is down */
2404
2405 if (!sisusb->SiS_Pr)
2406 return 1;
2407
2408 sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
2409 sisusb->SiS_Pr->sisusb = (void *)sisusb;
2410
2411 /* Set mode 0x03 */
2412 SiSUSBSetMode(sisusb->SiS_Pr, 0x03);
2413
2414 if (!(myfont = find_font("VGA8x16")))
2415 return 1;
2416
2417 if (!(tempbuf = vmalloc(8192)))
2418 return 1;
2419
2420 for (i = 0; i < 256; i++)
2421 memcpy(tempbuf + (i * 32), myfont->data + (i * 16), 16);
2422
2423 /* Upload default font */
2424 ret = sisusbcon_do_font_op(sisusb, 1, 0, tempbuf, 8192, 0, 1, NULL, 16, 0);
2425
2426 vfree(tempbuf);
2427
2428 /* Upload user font (and reset current slot) */
2429 if (sisusb->font_backup) {
2430 ret |= sisusbcon_do_font_op(sisusb, 1, 2, sisusb->font_backup,
2431 8192, sisusb->font_backup_512, 1, NULL,
2432 sisusb->font_backup_height, 0);
2433 if (slot != 2)
2434 sisusbcon_do_font_op(sisusb, 1, 0, NULL, 0, 0, 1,
2435 NULL, 16, 0);
2436 }
2437
2438 if (init && !sisusb->scrbuf) {
2439
2440 if ((tempbuf = vmalloc(8192))) {
2441
2442 i = 4096;
2443 tempbufb = (u16 *)tempbuf;
2444 while (i--)
2445 *(tempbufb++) = 0x0720;
2446
2447 i = 0;
2448 tempbufb = (u16 *)tempbuf;
2449 while (bootlogo[i]) {
2450 *(tempbufb++) = 0x0700 | bootlogo[i++];
2451 if (!(i % 4))
2452 tempbufb += 76;
2453 }
2454
2455 i = 0;
2456 tempbufb = (u16 *)tempbuf + 6;
2457 while (bootstring[i])
2458 *(tempbufb++) = 0x0700 | bootstring[i++];
2459
2460 ret |= sisusb_copy_memory(sisusb, tempbuf,
2461 sisusb->vrambase, 8192, &written);
2462
2463 vfree(tempbuf);
2464
2465 }
2466
2467 } else if (sisusb->scrbuf) {
2468
2469 ret |= sisusb_copy_memory(sisusb, (char *)sisusb->scrbuf,
2470 sisusb->vrambase, sisusb->scrbuf_size, &written);
2471
2472 }
2473
2474 if (sisusb->sisusb_cursor_size_from >= 0 &&
2475 sisusb->sisusb_cursor_size_to >= 0) {
2476 sisusb_setidxreg(sisusb, SISCR, 0x0a,
2477 sisusb->sisusb_cursor_size_from);
2478 sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0xe0,
2479 sisusb->sisusb_cursor_size_to);
2480 } else {
2481 sisusb_setidxreg(sisusb, SISCR, 0x0a, 0x2d);
2482 sisusb_setidxreg(sisusb, SISCR, 0x0b, 0x0e);
2483 sisusb->sisusb_cursor_size_to = -1;
2484 }
2485
2486 slot = sisusb->sisusb_cursor_loc;
2487 if(slot < 0) slot = 0;
2488
2489 sisusb->sisusb_cursor_loc = -1;
2490 sisusb->bad_cursor_pos = 1;
2491
2492 sisusb_set_cursor(sisusb, slot);
2493
2494 sisusb_setidxreg(sisusb, SISCR, 0x0c, (sisusb->cur_start_addr >> 8));
2495 sisusb_setidxreg(sisusb, SISCR, 0x0d, (sisusb->cur_start_addr & 0xff));
2496
2497 sisusb->textmodedestroyed = 0;
2498
2499 /* sisusb->lock is down */
2500
2501 return ret;
2502 }
2503
2504 #endif
2505
2506 /* fops */
2507
2508 static int
2509 sisusb_open(struct inode *inode, struct file *file)
2510 {
2511 struct sisusb_usb_data *sisusb;
2512 struct usb_interface *interface;
2513 int subminor = iminor(inode);
2514
2515 mutex_lock(&disconnect_mutex);
2516
2517 if (!(interface = usb_find_interface(&sisusb_driver, subminor))) {
2518 printk(KERN_ERR "sisusb[%d]: Failed to find interface\n",
2519 subminor);
2520 mutex_unlock(&disconnect_mutex);
2521 return -ENODEV;
2522 }
2523
2524 if (!(sisusb = usb_get_intfdata(interface))) {
2525 mutex_unlock(&disconnect_mutex);
2526 return -ENODEV;
2527 }
2528
2529 mutex_lock(&sisusb->lock);
2530
2531 if (!sisusb->present || !sisusb->ready) {
2532 mutex_unlock(&sisusb->lock);
2533 mutex_unlock(&disconnect_mutex);
2534 return -ENODEV;
2535 }
2536
2537 if (sisusb->isopen) {
2538 mutex_unlock(&sisusb->lock);
2539 mutex_unlock(&disconnect_mutex);
2540 return -EBUSY;
2541 }
2542
2543 if (!sisusb->devinit) {
2544 if (sisusb->sisusb_dev->speed == USB_SPEED_HIGH) {
2545 if (sisusb_init_gfxdevice(sisusb, 0)) {
2546 mutex_unlock(&sisusb->lock);
2547 mutex_unlock(&disconnect_mutex);
2548 printk(KERN_ERR
2549 "sisusbvga[%d]: Failed to initialize "
2550 "device\n",
2551 sisusb->minor);
2552 return -EIO;
2553 }
2554 } else {
2555 mutex_unlock(&sisusb->lock);
2556 mutex_unlock(&disconnect_mutex);
2557 printk(KERN_ERR
2558 "sisusbvga[%d]: Device not attached to "
2559 "USB 2.0 hub\n",
2560 sisusb->minor);
2561 return -EIO;
2562 }
2563 }
2564
2565 /* Increment usage count for our sisusb */
2566 kref_get(&sisusb->kref);
2567
2568 sisusb->isopen = 1;
2569
2570 file->private_data = sisusb;
2571
2572 mutex_unlock(&sisusb->lock);
2573
2574 mutex_unlock(&disconnect_mutex);
2575
2576 return 0;
2577 }
2578
2579 void
2580 sisusb_delete(struct kref *kref)
2581 {
2582 struct sisusb_usb_data *sisusb = to_sisusb_dev(kref);
2583
2584 if (!sisusb)
2585 return;
2586
2587 if (sisusb->sisusb_dev)
2588 usb_put_dev(sisusb->sisusb_dev);
2589
2590 sisusb->sisusb_dev = NULL;
2591 sisusb_free_buffers(sisusb);
2592 sisusb_free_urbs(sisusb);
2593 #ifdef INCL_SISUSB_CON
2594 kfree(sisusb->SiS_Pr);
2595 #endif
2596 kfree(sisusb);
2597 }
2598
2599 static int
2600 sisusb_release(struct inode *inode, struct file *file)
2601 {
2602 struct sisusb_usb_data *sisusb;
2603 int myminor;
2604
2605 mutex_lock(&disconnect_mutex);
2606
2607 if (!(sisusb = (struct sisusb_usb_data *)file->private_data)) {
2608 mutex_unlock(&disconnect_mutex);
2609 return -ENODEV;
2610 }
2611
2612 mutex_lock(&sisusb->lock);
2613
2614 if (sisusb->present) {
2615 /* Wait for all URBs to finish if device still present */
2616 if (!sisusb_wait_all_out_complete(sisusb))
2617 sisusb_kill_all_busy(sisusb);
2618 }
2619
2620 myminor = sisusb->minor;
2621
2622 sisusb->isopen = 0;
2623 file->private_data = NULL;
2624
2625 mutex_unlock(&sisusb->lock);
2626
2627 /* decrement the usage count on our device */
2628 kref_put(&sisusb->kref, sisusb_delete);
2629
2630 mutex_unlock(&disconnect_mutex);
2631
2632 return 0;
2633 }
2634
2635 static ssize_t
2636 sisusb_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2637 {
2638 struct sisusb_usb_data *sisusb;
2639 ssize_t bytes_read = 0;
2640 int errno = 0;
2641 u8 buf8;
2642 u16 buf16;
2643 u32 buf32, address;
2644
2645 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
2646 return -ENODEV;
2647
2648 mutex_lock(&sisusb->lock);
2649
2650 /* Sanity check */
2651 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
2652 mutex_unlock(&sisusb->lock);
2653 return -ENODEV;
2654 }
2655
2656 if ((*ppos) >= SISUSB_PCI_PSEUDO_IOPORTBASE &&
2657 (*ppos) < SISUSB_PCI_PSEUDO_IOPORTBASE + 128) {
2658
2659 address = (*ppos) -
2660 SISUSB_PCI_PSEUDO_IOPORTBASE +
2661 SISUSB_PCI_IOPORTBASE;
2662
2663 /* Read i/o ports
2664 * Byte, word and long(32) can be read. As this
2665 * emulates inX instructions, the data returned is
2666 * in machine-endianness.
2667 */
2668 switch (count) {
2669
2670 case 1:
2671 if (sisusb_read_memio_byte(sisusb,
2672 SISUSB_TYPE_IO,
2673 address, &buf8))
2674 errno = -EIO;
2675 else if (put_user(buf8, (u8 __user *)buffer))
2676 errno = -EFAULT;
2677 else
2678 bytes_read = 1;
2679
2680 break;
2681
2682 case 2:
2683 if (sisusb_read_memio_word(sisusb,
2684 SISUSB_TYPE_IO,
2685 address, &buf16))
2686 errno = -EIO;
2687 else if (put_user(buf16, (u16 __user *)buffer))
2688 errno = -EFAULT;
2689 else
2690 bytes_read = 2;
2691
2692 break;
2693
2694 case 4:
2695 if (sisusb_read_memio_long(sisusb,
2696 SISUSB_TYPE_IO,
2697 address, &buf32))
2698 errno = -EIO;
2699 else if (put_user(buf32, (u32 __user *)buffer))
2700 errno = -EFAULT;
2701 else
2702 bytes_read = 4;
2703
2704 break;
2705
2706 default:
2707 errno = -EIO;
2708
2709 }
2710
2711 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_MEMBASE &&
2712 (*ppos) < SISUSB_PCI_PSEUDO_MEMBASE + sisusb->vramsize) {
2713
2714 address = (*ppos) -
2715 SISUSB_PCI_PSEUDO_MEMBASE +
2716 SISUSB_PCI_MEMBASE;
2717
2718 /* Read video ram
2719 * Remember: Data delivered is never endian-corrected
2720 */
2721 errno = sisusb_read_mem_bulk(sisusb, address,
2722 NULL, count, buffer, &bytes_read);
2723
2724 if (bytes_read)
2725 errno = bytes_read;
2726
2727 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_MMIOBASE &&
2728 (*ppos) < SISUSB_PCI_PSEUDO_MMIOBASE + SISUSB_PCI_MMIOSIZE) {
2729
2730 address = (*ppos) -
2731 SISUSB_PCI_PSEUDO_MMIOBASE +
2732 SISUSB_PCI_MMIOBASE;
2733
2734 /* Read MMIO
2735 * Remember: Data delivered is never endian-corrected
2736 */
2737 errno = sisusb_read_mem_bulk(sisusb, address,
2738 NULL, count, buffer, &bytes_read);
2739
2740 if (bytes_read)
2741 errno = bytes_read;
2742
2743 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_PCIBASE &&
2744 (*ppos) <= SISUSB_PCI_PSEUDO_PCIBASE + 0x5c) {
2745
2746 if (count != 4) {
2747 mutex_unlock(&sisusb->lock);
2748 return -EINVAL;
2749 }
2750
2751 address = (*ppos) - SISUSB_PCI_PSEUDO_PCIBASE;
2752
2753 /* Read PCI config register
2754 * Return value delivered in machine endianness.
2755 */
2756 if (sisusb_read_pci_config(sisusb, address, &buf32))
2757 errno = -EIO;
2758 else if (put_user(buf32, (u32 __user *)buffer))
2759 errno = -EFAULT;
2760 else
2761 bytes_read = 4;
2762
2763 } else {
2764
2765 errno = -EBADFD;
2766
2767 }
2768
2769 (*ppos) += bytes_read;
2770
2771 mutex_unlock(&sisusb->lock);
2772
2773 return errno ? errno : bytes_read;
2774 }
2775
2776 static ssize_t
2777 sisusb_write(struct file *file, const char __user *buffer, size_t count,
2778 loff_t *ppos)
2779 {
2780 struct sisusb_usb_data *sisusb;
2781 int errno = 0;
2782 ssize_t bytes_written = 0;
2783 u8 buf8;
2784 u16 buf16;
2785 u32 buf32, address;
2786
2787 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
2788 return -ENODEV;
2789
2790 mutex_lock(&sisusb->lock);
2791
2792 /* Sanity check */
2793 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
2794 mutex_unlock(&sisusb->lock);
2795 return -ENODEV;
2796 }
2797
2798 if ((*ppos) >= SISUSB_PCI_PSEUDO_IOPORTBASE &&
2799 (*ppos) < SISUSB_PCI_PSEUDO_IOPORTBASE + 128) {
2800
2801 address = (*ppos) -
2802 SISUSB_PCI_PSEUDO_IOPORTBASE +
2803 SISUSB_PCI_IOPORTBASE;
2804
2805 /* Write i/o ports
2806 * Byte, word and long(32) can be written. As this
2807 * emulates outX instructions, the data is expected
2808 * in machine-endianness.
2809 */
2810 switch (count) {
2811
2812 case 1:
2813 if (get_user(buf8, (u8 __user *)buffer))
2814 errno = -EFAULT;
2815 else if (sisusb_write_memio_byte(sisusb,
2816 SISUSB_TYPE_IO,
2817 address, buf8))
2818 errno = -EIO;
2819 else
2820 bytes_written = 1;
2821
2822 break;
2823
2824 case 2:
2825 if (get_user(buf16, (u16 __user *)buffer))
2826 errno = -EFAULT;
2827 else if (sisusb_write_memio_word(sisusb,
2828 SISUSB_TYPE_IO,
2829 address, buf16))
2830 errno = -EIO;
2831 else
2832 bytes_written = 2;
2833
2834 break;
2835
2836 case 4:
2837 if (get_user(buf32, (u32 __user *)buffer))
2838 errno = -EFAULT;
2839 else if (sisusb_write_memio_long(sisusb,
2840 SISUSB_TYPE_IO,
2841 address, buf32))
2842 errno = -EIO;
2843 else
2844 bytes_written = 4;
2845
2846 break;
2847
2848 default:
2849 errno = -EIO;
2850 }
2851
2852 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_MEMBASE &&
2853 (*ppos) < SISUSB_PCI_PSEUDO_MEMBASE + sisusb->vramsize) {
2854
2855 address = (*ppos) -
2856 SISUSB_PCI_PSEUDO_MEMBASE +
2857 SISUSB_PCI_MEMBASE;
2858
2859 /* Write video ram.
2860 * Buffer is copied 1:1, therefore, on big-endian
2861 * machines, the data must be swapped by userland
2862 * in advance (if applicable; no swapping in 8bpp
2863 * mode or if YUV data is being transferred).
2864 */
2865 errno = sisusb_write_mem_bulk(sisusb, address, NULL,
2866 count, buffer, 0, &bytes_written);
2867
2868 if (bytes_written)
2869 errno = bytes_written;
2870
2871 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_MMIOBASE &&
2872 (*ppos) < SISUSB_PCI_PSEUDO_MMIOBASE + SISUSB_PCI_MMIOSIZE) {
2873
2874 address = (*ppos) -
2875 SISUSB_PCI_PSEUDO_MMIOBASE +
2876 SISUSB_PCI_MMIOBASE;
2877
2878 /* Write MMIO.
2879 * Buffer is copied 1:1, therefore, on big-endian
2880 * machines, the data must be swapped by userland
2881 * in advance.
2882 */
2883 errno = sisusb_write_mem_bulk(sisusb, address, NULL,
2884 count, buffer, 0, &bytes_written);
2885
2886 if (bytes_written)
2887 errno = bytes_written;
2888
2889 } else if ((*ppos) >= SISUSB_PCI_PSEUDO_PCIBASE &&
2890 (*ppos) <= SISUSB_PCI_PSEUDO_PCIBASE + SISUSB_PCI_PCONFSIZE) {
2891
2892 if (count != 4) {
2893 mutex_unlock(&sisusb->lock);
2894 return -EINVAL;
2895 }
2896
2897 address = (*ppos) - SISUSB_PCI_PSEUDO_PCIBASE;
2898
2899 /* Write PCI config register.
2900 * Given value expected in machine endianness.
2901 */
2902 if (get_user(buf32, (u32 __user *)buffer))
2903 errno = -EFAULT;
2904 else if (sisusb_write_pci_config(sisusb, address, buf32))
2905 errno = -EIO;
2906 else
2907 bytes_written = 4;
2908
2909
2910 } else {
2911
2912 /* Error */
2913 errno = -EBADFD;
2914
2915 }
2916
2917 (*ppos) += bytes_written;
2918
2919 mutex_unlock(&sisusb->lock);
2920
2921 return errno ? errno : bytes_written;
2922 }
2923
2924 static loff_t
2925 sisusb_lseek(struct file *file, loff_t offset, int orig)
2926 {
2927 struct sisusb_usb_data *sisusb;
2928 loff_t ret;
2929
2930 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
2931 return -ENODEV;
2932
2933 mutex_lock(&sisusb->lock);
2934
2935 /* Sanity check */
2936 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
2937 mutex_unlock(&sisusb->lock);
2938 return -ENODEV;
2939 }
2940
2941 switch (orig) {
2942 case 0:
2943 file->f_pos = offset;
2944 ret = file->f_pos;
2945 /* never negative, no force_successful_syscall needed */
2946 break;
2947 case 1:
2948 file->f_pos += offset;
2949 ret = file->f_pos;
2950 /* never negative, no force_successful_syscall needed */
2951 break;
2952 default:
2953 /* seeking relative to "end of file" is not supported */
2954 ret = -EINVAL;
2955 }
2956
2957 mutex_unlock(&sisusb->lock);
2958 return ret;
2959 }
2960
2961 static int
2962 sisusb_handle_command(struct sisusb_usb_data *sisusb, struct sisusb_command *y,
2963 unsigned long arg)
2964 {
2965 int retval, port, length;
2966 u32 address;
2967
2968 /* All our commands require the device
2969 * to be initialized.
2970 */
2971 if (!sisusb->devinit)
2972 return -ENODEV;
2973
2974 port = y->data3 -
2975 SISUSB_PCI_PSEUDO_IOPORTBASE +
2976 SISUSB_PCI_IOPORTBASE;
2977
2978 switch (y->operation) {
2979 case SUCMD_GET:
2980 retval = sisusb_getidxreg(sisusb, port,
2981 y->data0, &y->data1);
2982 if (!retval) {
2983 if (copy_to_user((void __user *)arg, y,
2984 sizeof(*y)))
2985 retval = -EFAULT;
2986 }
2987 break;
2988
2989 case SUCMD_SET:
2990 retval = sisusb_setidxreg(sisusb, port,
2991 y->data0, y->data1);
2992 break;
2993
2994 case SUCMD_SETOR:
2995 retval = sisusb_setidxregor(sisusb, port,
2996 y->data0, y->data1);
2997 break;
2998
2999 case SUCMD_SETAND:
3000 retval = sisusb_setidxregand(sisusb, port,
3001 y->data0, y->data1);
3002 break;
3003
3004 case SUCMD_SETANDOR:
3005 retval = sisusb_setidxregandor(sisusb, port,
3006 y->data0, y->data1, y->data2);
3007 break;
3008
3009 case SUCMD_SETMASK:
3010 retval = sisusb_setidxregmask(sisusb, port,
3011 y->data0, y->data1, y->data2);
3012 break;
3013
3014 case SUCMD_CLRSCR:
3015 /* Gfx core must be initialized */
3016 if (!sisusb->gfxinit)
3017 return -ENODEV;
3018
3019 length = (y->data0 << 16) | (y->data1 << 8) | y->data2;
3020 address = y->data3 -
3021 SISUSB_PCI_PSEUDO_MEMBASE +
3022 SISUSB_PCI_MEMBASE;
3023 retval = sisusb_clear_vram(sisusb, address, length);
3024 break;
3025
3026 case SUCMD_HANDLETEXTMODE:
3027 retval = 0;
3028 #ifdef INCL_SISUSB_CON
3029 /* Gfx core must be initialized, SiS_Pr must exist */
3030 if (!sisusb->gfxinit || !sisusb->SiS_Pr)
3031 return -ENODEV;
3032
3033 switch (y->data0) {
3034 case 0:
3035 retval = sisusb_reset_text_mode(sisusb, 0);
3036 break;
3037 case 1:
3038 sisusb->textmodedestroyed = 1;
3039 break;
3040 }
3041 #endif
3042 break;
3043
3044 #ifdef INCL_SISUSB_CON
3045 case SUCMD_SETMODE:
3046 /* Gfx core must be initialized, SiS_Pr must exist */
3047 if (!sisusb->gfxinit || !sisusb->SiS_Pr)
3048 return -ENODEV;
3049
3050 retval = 0;
3051
3052 sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
3053 sisusb->SiS_Pr->sisusb = (void *)sisusb;
3054
3055 if (SiSUSBSetMode(sisusb->SiS_Pr, y->data3))
3056 retval = -EINVAL;
3057
3058 break;
3059
3060 case SUCMD_SETVESAMODE:
3061 /* Gfx core must be initialized, SiS_Pr must exist */
3062 if (!sisusb->gfxinit || !sisusb->SiS_Pr)
3063 return -ENODEV;
3064
3065 retval = 0;
3066
3067 sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
3068 sisusb->SiS_Pr->sisusb = (void *)sisusb;
3069
3070 if (SiSUSBSetVESAMode(sisusb->SiS_Pr, y->data3))
3071 retval = -EINVAL;
3072
3073 break;
3074 #endif
3075
3076 default:
3077 retval = -EINVAL;
3078 }
3079
3080 if (retval > 0)
3081 retval = -EIO;
3082
3083 return retval;
3084 }
3085
3086 static int
3087 sisusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
3088 unsigned long arg)
3089 {
3090 struct sisusb_usb_data *sisusb;
3091 struct sisusb_info x;
3092 struct sisusb_command y;
3093 int retval = 0;
3094 u32 __user *argp = (u32 __user *)arg;
3095
3096 if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
3097 return -ENODEV;
3098
3099 mutex_lock(&sisusb->lock);
3100
3101 /* Sanity check */
3102 if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev) {
3103 retval = -ENODEV;
3104 goto err_out;
3105 }
3106
3107 switch (cmd) {
3108
3109 case SISUSB_GET_CONFIG_SIZE:
3110
3111 if (put_user(sizeof(x), argp))
3112 retval = -EFAULT;
3113
3114 break;
3115
3116 case SISUSB_GET_CONFIG:
3117
3118 x.sisusb_id = SISUSB_ID;
3119 x.sisusb_version = SISUSB_VERSION;
3120 x.sisusb_revision = SISUSB_REVISION;
3121 x.sisusb_patchlevel = SISUSB_PATCHLEVEL;
3122 x.sisusb_gfxinit = sisusb->gfxinit;
3123 x.sisusb_vrambase = SISUSB_PCI_PSEUDO_MEMBASE;
3124 x.sisusb_mmiobase = SISUSB_PCI_PSEUDO_MMIOBASE;
3125 x.sisusb_iobase = SISUSB_PCI_PSEUDO_IOPORTBASE;
3126 x.sisusb_pcibase = SISUSB_PCI_PSEUDO_PCIBASE;
3127 x.sisusb_vramsize = sisusb->vramsize;
3128 x.sisusb_minor = sisusb->minor;
3129 x.sisusb_fbdevactive= 0;
3130 #ifdef INCL_SISUSB_CON
3131 x.sisusb_conactive = sisusb->haveconsole ? 1 : 0;
3132 #else
3133 x.sisusb_conactive = 0;
3134 #endif
3135
3136 if (copy_to_user((void __user *)arg, &x, sizeof(x)))
3137 retval = -EFAULT;
3138
3139 break;
3140
3141 case SISUSB_COMMAND:
3142
3143 if (copy_from_user(&y, (void __user *)arg, sizeof(y)))
3144 retval = -EFAULT;
3145 else
3146 retval = sisusb_handle_command(sisusb, &y, arg);
3147
3148 break;
3149
3150 default:
3151 retval = -ENOTTY;
3152 break;
3153 }
3154
3155 err_out:
3156 mutex_unlock(&sisusb->lock);
3157 return retval;
3158 }
3159
3160 #ifdef SISUSB_NEW_CONFIG_COMPAT
3161 static long
3162 sisusb_compat_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
3163 {
3164 long retval;
3165
3166 switch (cmd) {
3167 case SISUSB_GET_CONFIG_SIZE:
3168 case SISUSB_GET_CONFIG:
3169 case SISUSB_COMMAND:
3170 lock_kernel();
3171 retval = sisusb_ioctl(f->f_dentry->d_inode, f, cmd, arg);
3172 unlock_kernel();
3173 return retval;
3174
3175 default:
3176 return -ENOIOCTLCMD;
3177 }
3178 }
3179 #endif
3180
3181 static const struct file_operations usb_sisusb_fops = {
3182 .owner = THIS_MODULE,
3183 .open = sisusb_open,
3184 .release = sisusb_release,
3185 .read = sisusb_read,
3186 .write = sisusb_write,
3187 .llseek = sisusb_lseek,
3188 #ifdef SISUSB_NEW_CONFIG_COMPAT
3189 .compat_ioctl = sisusb_compat_ioctl,
3190 #endif
3191 .ioctl = sisusb_ioctl
3192 };
3193
3194 static struct usb_class_driver usb_sisusb_class = {
3195 .name = "sisusbvga%d",
3196 .fops = &usb_sisusb_fops,
3197 .minor_base = SISUSB_MINOR
3198 };
3199
3200 static int sisusb_probe(struct usb_interface *intf,
3201 const struct usb_device_id *id)
3202 {
3203 struct usb_device *dev = interface_to_usbdev(intf);
3204 struct sisusb_usb_data *sisusb;
3205 int retval = 0, i;
3206 const char *memfail =
3207 KERN_ERR
3208 "sisusbvga[%d]: Failed to allocate memory for %s buffer\n";
3209
3210 printk(KERN_INFO "sisusb: USB2VGA dongle found at address %d\n",
3211 dev->devnum);
3212
3213 /* Allocate memory for our private */
3214 if (!(sisusb = kzalloc(sizeof(*sisusb), GFP_KERNEL))) {
3215 printk(KERN_ERR
3216 "sisusb: Failed to allocate memory for private data\n");
3217 return -ENOMEM;
3218 }
3219 kref_init(&sisusb->kref);
3220
3221 mutex_init(&(sisusb->lock));
3222
3223 /* Register device */
3224 if ((retval = usb_register_dev(intf, &usb_sisusb_class))) {
3225 printk(KERN_ERR
3226 "sisusb: Failed to get a minor for device %d\n",
3227 dev->devnum);
3228 retval = -ENODEV;
3229 goto error_1;
3230 }
3231
3232 sisusb->sisusb_dev = dev;
3233 sisusb->minor = intf->minor;
3234 sisusb->vrambase = SISUSB_PCI_MEMBASE;
3235 sisusb->mmiobase = SISUSB_PCI_MMIOBASE;
3236 sisusb->mmiosize = SISUSB_PCI_MMIOSIZE;
3237 sisusb->ioportbase = SISUSB_PCI_IOPORTBASE;
3238 /* Everything else is zero */
3239
3240 /* Allocate buffers */
3241 sisusb->ibufsize = SISUSB_IBUF_SIZE;
3242 if (!(sisusb->ibuf = usb_buffer_alloc(dev, SISUSB_IBUF_SIZE,
3243 GFP_KERNEL, &sisusb->transfer_dma_in))) {
3244 printk(memfail, "input", sisusb->minor);
3245 retval = -ENOMEM;
3246 goto error_2;
3247 }
3248
3249 sisusb->numobufs = 0;
3250 sisusb->obufsize = SISUSB_OBUF_SIZE;
3251 for (i = 0; i < NUMOBUFS; i++) {
3252 if (!(sisusb->obuf[i] = usb_buffer_alloc(dev, SISUSB_OBUF_SIZE,
3253 GFP_KERNEL,
3254 &sisusb->transfer_dma_out[i]))) {
3255 if (i == 0) {
3256 printk(memfail, "output", sisusb->minor);
3257 retval = -ENOMEM;
3258 goto error_3;
3259 }
3260 break;
3261 } else
3262 sisusb->numobufs++;
3263
3264 }
3265
3266 /* Allocate URBs */
3267 if (!(sisusb->sisurbin = usb_alloc_urb(0, GFP_KERNEL))) {
3268 printk(KERN_ERR
3269 "sisusbvga[%d]: Failed to allocate URBs\n",
3270 sisusb->minor);
3271 retval = -ENOMEM;
3272 goto error_3;
3273 }
3274 sisusb->completein = 1;
3275
3276 for (i = 0; i < sisusb->numobufs; i++) {
3277 if (!(sisusb->sisurbout[i] = usb_alloc_urb(0, GFP_KERNEL))) {
3278 printk(KERN_ERR
3279 "sisusbvga[%d]: Failed to allocate URBs\n",
3280 sisusb->minor);
3281 retval = -ENOMEM;
3282 goto error_4;
3283 }
3284 sisusb->urbout_context[i].sisusb = (void *)sisusb;
3285 sisusb->urbout_context[i].urbindex = i;
3286 sisusb->urbstatus[i] = 0;
3287 }
3288
3289 printk(KERN_INFO "sisusbvga[%d]: Allocated %d output buffers\n",
3290 sisusb->minor, sisusb->numobufs);
3291
3292 #ifdef INCL_SISUSB_CON
3293 /* Allocate our SiS_Pr */
3294 if (!(sisusb->SiS_Pr = kmalloc(sizeof(struct SiS_Private), GFP_KERNEL))) {
3295 printk(KERN_ERR
3296 "sisusbvga[%d]: Failed to allocate SiS_Pr\n",
3297 sisusb->minor);
3298 }
3299 #endif
3300
3301 /* Do remaining init stuff */
3302
3303 init_waitqueue_head(&sisusb->wait_q);
3304
3305 usb_set_intfdata(intf, sisusb);
3306
3307 usb_get_dev(sisusb->sisusb_dev);
3308
3309 sisusb->present = 1;
3310
3311 #ifdef SISUSB_OLD_CONFIG_COMPAT
3312 {
3313 int ret;
3314 /* Our ioctls are all "32/64bit compatible" */
3315 ret = register_ioctl32_conversion(SISUSB_GET_CONFIG_SIZE, NULL);
3316 ret |= register_ioctl32_conversion(SISUSB_GET_CONFIG, NULL);
3317 ret |= register_ioctl32_conversion(SISUSB_COMMAND, NULL);
3318 if (ret)
3319 printk(KERN_ERR
3320 "sisusbvga[%d]: Error registering ioctl32 "
3321 "translations\n",
3322 sisusb->minor);
3323 else
3324 sisusb->ioctl32registered = 1;
3325 }
3326 #endif
3327
3328 if (dev->speed == USB_SPEED_HIGH) {
3329 int initscreen = 1;
3330 #ifdef INCL_SISUSB_CON
3331 if (sisusb_first_vc > 0 &&
3332 sisusb_last_vc > 0 &&
3333 sisusb_first_vc <= sisusb_last_vc &&
3334 sisusb_last_vc <= MAX_NR_CONSOLES)
3335 initscreen = 0;
3336 #endif
3337 if (sisusb_init_gfxdevice(sisusb, initscreen))
3338 printk(KERN_ERR
3339 "sisusbvga[%d]: Failed to early "
3340 "initialize device\n",
3341 sisusb->minor);
3342
3343 } else
3344 printk(KERN_INFO
3345 "sisusbvga[%d]: Not attached to USB 2.0 hub, "
3346 "deferring init\n",
3347 sisusb->minor);
3348
3349 sisusb->ready = 1;
3350
3351 #ifdef SISUSBENDIANTEST
3352 printk(KERN_DEBUG "sisusb: *** RWTEST ***\n");
3353 sisusb_testreadwrite(sisusb);
3354 printk(KERN_DEBUG "sisusb: *** RWTEST END ***\n");
3355 #endif
3356
3357 #ifdef INCL_SISUSB_CON
3358 sisusb_console_init(sisusb, sisusb_first_vc, sisusb_last_vc);
3359 #endif
3360
3361 return 0;
3362
3363 error_4:
3364 sisusb_free_urbs(sisusb);
3365 error_3:
3366 sisusb_free_buffers(sisusb);
3367 error_2:
3368 usb_deregister_dev(intf, &usb_sisusb_class);
3369 error_1:
3370 kfree(sisusb);
3371 return retval;
3372 }
3373
3374 static void sisusb_disconnect(struct usb_interface *intf)
3375 {
3376 struct sisusb_usb_data *sisusb;
3377 int minor;
3378
3379 /* This should *not* happen */
3380 if (!(sisusb = usb_get_intfdata(intf)))
3381 return;
3382
3383 #ifdef INCL_SISUSB_CON
3384 sisusb_console_exit(sisusb);
3385 #endif
3386
3387 /* The above code doesn't need the disconnect
3388 * semaphore to be down; its meaning is to
3389 * protect all other routines from the disconnect
3390 * case, not the other way round.
3391 */
3392 mutex_lock(&disconnect_mutex);
3393
3394 mutex_lock(&sisusb->lock);
3395
3396 /* Wait for all URBs to complete and kill them in case (MUST do) */
3397 if (!sisusb_wait_all_out_complete(sisusb))
3398 sisusb_kill_all_busy(sisusb);
3399
3400 minor = sisusb->minor;
3401
3402 usb_set_intfdata(intf, NULL);
3403
3404 usb_deregister_dev(intf, &usb_sisusb_class);
3405
3406 #ifdef SISUSB_OLD_CONFIG_COMPAT
3407 if (sisusb->ioctl32registered) {
3408 int ret;
3409 sisusb->ioctl32registered = 0;
3410 ret = unregister_ioctl32_conversion(SISUSB_GET_CONFIG_SIZE);
3411 ret |= unregister_ioctl32_conversion(SISUSB_GET_CONFIG);
3412 ret |= unregister_ioctl32_conversion(SISUSB_COMMAND);
3413 if (ret) {
3414 printk(KERN_ERR
3415 "sisusbvga[%d]: Error unregistering "
3416 "ioctl32 translations\n",
3417 minor);
3418 }
3419 }
3420 #endif
3421
3422 sisusb->present = 0;
3423 sisusb->ready = 0;
3424
3425 mutex_unlock(&sisusb->lock);
3426
3427 /* decrement our usage count */
3428 kref_put(&sisusb->kref, sisusb_delete);
3429
3430 mutex_unlock(&disconnect_mutex);
3431
3432 printk(KERN_INFO "sisusbvga[%d]: Disconnected\n", minor);
3433 }
3434
3435 static struct usb_device_id sisusb_table [] = {
3436 { USB_DEVICE(0x0711, 0x0900) },
3437 { USB_DEVICE(0x0711, 0x0901) },
3438 { USB_DEVICE(0x0711, 0x0902) },
3439 { USB_DEVICE(0x182d, 0x021c) },
3440 { USB_DEVICE(0x182d, 0x0269) },
3441 { }
3442 };
3443
3444 MODULE_DEVICE_TABLE (usb, sisusb_table);
3445
3446 static struct usb_driver sisusb_driver = {
3447 .name = "sisusb",
3448 .probe = sisusb_probe,
3449 .disconnect = sisusb_disconnect,
3450 .id_table = sisusb_table,
3451 };
3452
3453 static int __init usb_sisusb_init(void)
3454 {
3455 int retval;
3456
3457 #ifdef INCL_SISUSB_CON
3458 sisusb_init_concode();
3459 #endif
3460
3461 if (!(retval = usb_register(&sisusb_driver))) {
3462
3463 printk(KERN_INFO "sisusb: Driver version %d.%d.%d\n",
3464 SISUSB_VERSION, SISUSB_REVISION, SISUSB_PATCHLEVEL);
3465 printk(KERN_INFO
3466 "sisusb: Copyright (C) 2005 Thomas Winischhofer\n");
3467
3468 }
3469
3470 return retval;
3471 }
3472
3473 static void __exit usb_sisusb_exit(void)
3474 {
3475 usb_deregister(&sisusb_driver);
3476 }
3477
3478 module_init(usb_sisusb_init);
3479 module_exit(usb_sisusb_exit);
3480
3481 MODULE_AUTHOR("Thomas Winischhofer <thomas@winischhofer.net>");
3482 MODULE_DESCRIPTION("sisusbvga - Driver for Net2280/SiS315-based USB2VGA dongles");
3483 MODULE_LICENSE("GPL");
3484
(deprecated) Btrfs devel tree