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