Re: [PATCH] Add support for USB Keyboard attached to UHCI
Konstantin Baydarov <[email protected]> Fri, 30 Nov 2007 16:59:53 +0300
| Newsgroups | gmane.linux.kernel.debugging |
|---|---|
| Message-ID | <[email protected]> |
On Mon, 26 Nov 2007 13:39:41 -0800 (PST) Aaron Young <[email protected]> wrote: > > > Konstantin, some comments: > > 1. You added some USB specific code to kdba_io_32.c, namely > kdb_usb_fill_int_urb(), kdb_uhci_submit_urb(). > > Would it be better to put this USB code into the kernel uhci > files (uhci-q.c, uhci-hcd.c or whatever) so kdb can remain unaware > of USB specifics? > Also, I think if you did it this way, then it would remove the need > for the new interface routine kdb_usb_uhci_keyboard_attach(). You > should be able to just call kdb_usb_keyboard_attach() after you > create and submit the new URB from hid_probe(). Just add > a new parameter to kdb_usb_keyboard_attach() for the > complete_func and pass NULL for it for OHCI and EHCI. > > The USB infastructure is constantly being rewritten and > structures/parameters changing around, so it would be best to keep > those details over in the kernel and not in kdb IMO. > - Got rid from kdb_usb_uhci_keyboard_attach() - Added "poll_func" argument to kdb_usb_keyboard_attach() - Moved kdb_usb_fill_int_urb() and kdb_uhci_submit_urb() to hid-core.c. That fixes compilation errors (problem reported by jidong xiao) when USB subsystem is compiled as kernel module. > 2. What is the limiting factor preventing multiple keyboards? Is it > the use of the globals kdb_uhci_hid_qh and kdb_hid_event? Can this > be fixed somehow? Can they be put into the per device > kdb_usb_kbd_info struct maybe? > - Moved kdb_uhci_hid_qh and hid_event to kdb_usb_kbd_info. Now multiple UHCI keyboards are supported. > 4. I think you'll need to add your new interfaces to kdba_io_64.c > and arch/ia64/kdb/kdba_io.c. Otherwise, the USB modules will > encounter link/build errors when they can't find > kdb_usb_uhci_keyboard_attach() (and the other globals and such) on > those builds/systems. It would be nice to have UHCI support on those > archs too. > - Added x86_64 part. > 5. I already submitted another patch for EHCI support which will > conflict with this one (kdba_io_32.c). Can you add your patch on > top of that one? - Done. > > > -Aaron > Patch against kernel 2.6.24-rc2. Was tested on i386 kernel with 2 UHCI keyboards. Index: linux-2.6.24-rc2/drivers/usb/host/uhci-q.c =================================================================== --- linux-2.6.24-rc2.orig/drivers/usb/host/uhci-q.c +++ linux-2.6.24-rc2/drivers/usb/host/uhci-q.c @@ -25,6 +25,18 @@ * games with the FSBR code to make sure we get the correct order in all * the cases. I don't think it's worth the effort */ +#ifdef CONFIG_KDB_USB +/* KDB HID QH, managed by KDB code */ +extern int kdb_uhci_keyboard_chech_uhci_qh(struct uhci_qh *qh); +extern int kdb_uhci_keyboard_set_qh(struct urb *urb, struct uhci_qh *qh); +extern struct uhci_qh *kdb_uhci_keyboard_get_qh(struct urb *urb); +extern int kdb_uhci_keyboard_set_hid_event(struct urb *urb, int hid_event); +extern int kdb_uhci_keyboard_get_hid_event(struct urb *urb); +extern int kdb_uhci_keyboard_set_hid_event_qh(struct uhci_qh *qh, int hid_event); +extern int kdb_uhci_keyboard_get_hid_event_qh(struct uhci_qh *qh); +#endif + + static void uhci_set_next_interrupt(struct uhci_hcd *uhci) { if (uhci->is_stopped) @@ -292,6 +304,58 @@ static struct uhci_qh *uhci_alloc_qh(str return qh; } +#ifdef CONFIG_KDB_USB +/* + * Same as uhci_alloc_qh execpt it doesn't change to hep->hcpriv + */ +static struct uhci_qh *kdb_uhci_alloc_qh(struct uhci_hcd *uhci, + struct usb_device *udev, struct usb_host_endpoint *hep) +{ + dma_addr_t dma_handle; + struct uhci_qh *qh; + + qh = dma_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle); + if (!qh) + return NULL; + + memset(qh, 0, sizeof(*qh)); + qh->dma_handle = dma_handle; + + qh->element = UHCI_PTR_TERM; + qh->link = UHCI_PTR_TERM; + + INIT_LIST_HEAD(&qh->queue); + INIT_LIST_HEAD(&qh->node); + + if (udev) { /* Normal QH */ + qh->type = hep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; + if (qh->type != USB_ENDPOINT_XFER_ISOC) { + qh->dummy_td = uhci_alloc_td(uhci); + if (!qh->dummy_td) { + dma_pool_free(uhci->qh_pool, qh, dma_handle); + return NULL; + } + } + qh->state = QH_STATE_IDLE; + qh->hep = hep; + qh->udev = udev; + + if (qh->type == USB_ENDPOINT_XFER_INT || + qh->type == USB_ENDPOINT_XFER_ISOC) + qh->load = usb_calc_bus_time(udev->speed, + usb_endpoint_dir_in(&hep->desc), + qh->type == USB_ENDPOINT_XFER_ISOC, + le16_to_cpu(hep->desc.wMaxPacketSize)) + / 1000 + 1; + + } else { /* Skeleton QH */ + qh->state = QH_STATE_ACTIVE; + qh->type = -1; + } + return qh; +} +#endif + static void uhci_free_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) { WARN_ON(qh->state != QH_STATE_IDLE && qh->udev); @@ -1399,6 +1463,20 @@ static int uhci_urb_enqueue(struct usb_h if (!urbp) goto done; +#ifdef CONFIG_KDB_USB + /* Always allocate new QH for KDB URB. + * KDB HQ will be managed by KDB poll code not by + * UHCI HCD Driver. + */ + if (kdb_uhci_keyboard_urb(urb) != -1){ + /* KDB urb will be enqued only once */ + kdb_uhci_keyboard_set_qh(urb, NULL); + qh = kdb_uhci_alloc_qh(uhci, urb->dev, urb->ep); + if (!qh) + goto err_no_qh; + kdb_uhci_keyboard_set_qh(urb, qh); + } else +#endif if (urb->ep->hcpriv) qh = urb->ep->hcpriv; else { @@ -1648,6 +1726,13 @@ static int uhci_advance_check(struct uhc int ret = 1; unsigned status; +#ifdef CONFIG_KDB_USB + /* Don't manage KDB QH */ + if(kdb_uhci_keyboard_chech_uhci_qh(qh) != -1){ + ret = 0; + goto done; + } +#endif if (qh->type == USB_ENDPOINT_XFER_ISOC) goto done; @@ -1740,6 +1825,11 @@ rescan: uhci->next_qh = list_entry(qh->node.next, struct uhci_qh, node); +#ifdef CONFIG_KDB_USB + /* Don't manage KDB QH */ + if(kdb_uhci_keyboard_chech_uhci_qh(qh) != -1) + continue; +#endif if (uhci_advance_check(uhci, qh)) { uhci_scan_qh(uhci, qh); if (qh->state == QH_STATE_ACTIVE) { @@ -1766,3 +1856,76 @@ rescan: else uhci_set_next_interrupt(uhci); } + +#ifdef CONFIG_KDB_USB +/* + * Activate KDB UHCI QH, called by KDB poll code. + */ +static void kdb_activate_uhci_qh(struct uhci_qh *qh) +{ + struct urb_priv *urbp; + struct uhci_td *td; + __le32 status, token; + + urbp = list_entry(qh->queue.next, struct urb_priv, node); + + list_for_each_entry(td, &urbp->td_list, list){ + status = td->status; + token = td->token; + barrier(); + /* Clear Status and ActLen */ + status &= cpu_to_le32(0xff000000); + /* Make TD Active */ + status |= cpu_to_le32(TD_CTRL_ACTIVE); + /* Clear TD Interrupt */ + status &= cpu_to_le32(~TD_CTRL_IOC); + /* Toggle Data Sycronization Bit */ + if (token & cpu_to_le32(TD_TOKEN_TOGGLE)) + token &= cpu_to_le32(~TD_TOKEN_TOGGLE); + else + token |= cpu_to_le32(TD_TOKEN_TOGGLE); + + td->token = token; + td->status = status; + barrier(); + } + /* Activate KDB UHCI Keyboard HID QH */ + td = list_entry(urbp->td_list.next, struct uhci_td, list); + qh->element = LINK_TO_TD(td); + barrier(); +} + +/* + * Called when KDB finishes process key press/release event. + */ +static void +kdb_uhci_urb_complete (struct urb *urb) +{ + if (!kdb_uhci_keyboard_get_hid_event(urb)) + return; + + /* Activate KDB TD */ + kdb_activate_uhci_qh(kdb_uhci_keyboard_get_qh(urb)); + kdb_uhci_keyboard_set_hid_event(urb, 0); +} + +/* + * Check if state of KDB URB changed (key was pressed/released). + */ +static int uhci_check_kdb_uhci_qh(struct uhci_qh *qh) +{ + struct urb_priv *urbp = NULL; + struct uhci_td *td; + unsigned status; + + urbp = list_entry(qh->queue.next, struct urb_priv, node); + td = list_entry(urbp->td_list.next, struct uhci_td, list); + status = td_status(td); + if (!(status & TD_CTRL_ACTIVE)){ + /* We're okay, the queue has advanced */ + kdb_uhci_keyboard_set_hid_event_qh(qh, 1); + return 0; + } + return -1; +} +#endif Index: linux-2.6.24-rc2/drivers/hid/usbhid/hid-core.c =================================================================== --- linux-2.6.24-rc2.orig/drivers/hid/usbhid/hid-core.c +++ linux-2.6.24-rc2/drivers/hid/usbhid/hid-core.c @@ -969,6 +969,86 @@ static void hid_disconnect(struct usb_in hid_free_device(hid); } +#ifdef CONFIG_KDB_USB +/* Only 1 UHCI Keyboard supported */ +static inline void kdb_usb_fill_int_urb (struct urb *urb, + struct usb_device *dev, + unsigned int pipe, + void *transfer_buffer, + int buffer_length, + usb_complete_t complete_fn, + void *context, + int interval) +{ + urb->dev = dev; + urb->pipe = pipe; + urb->transfer_buffer = transfer_buffer; + urb->transfer_buffer_length = buffer_length; + urb->complete = complete_fn; + urb->context = context; + urb->interval = interval; + urb->start_frame = -1; +} + +static int kdb_uhci_submit_urb(struct usb_interface *intf, unsigned int usbhid_bufsize, struct urb *hid_inurb) +{ + struct urb *kdb_urb = NULL; + unsigned char *kdb_buffer; + dma_addr_t uhci_inbuf_dma; + int ret = -1; + extern void * usb_hcd_get_kdb_poll_func(struct usb_device *udev); + extern void * usb_hcd_get_kdb_completion_func(struct usb_device *udev); + + if (!(kdb_buffer = usb_buffer_alloc(hid_inurb->dev, + usbhid_bufsize, GFP_ATOMIC, + &uhci_inbuf_dma))) + goto out; + + if (!(kdb_urb = usb_alloc_urb(0, GFP_KERNEL))) + goto out; + + kdb_usb_fill_int_urb(kdb_urb, + hid_inurb->dev, + hid_inurb->pipe, + kdb_buffer, + hid_inurb->transfer_buffer_length, + hid_inurb->complete, + hid_inurb->context, + hid_inurb->interval + ); + + (kdb_urb)->transfer_dma = uhci_inbuf_dma; + (kdb_urb)->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; + + ret = kdb_usb_keyboard_attach(kdb_urb, kdb_buffer, + usb_hcd_get_kdb_poll_func(interface_to_usbdev(intf)), + usb_hcd_get_kdb_completion_func(interface_to_usbdev(intf))); + + if (ret){ + kdb_uhci_keyboard_clear(kdb_urb); + goto out; + } + + if (usb_submit_urb(kdb_urb, GFP_ATOMIC)) + goto out; + + ret = 0; + return ret; +out: + /* Some Error Cleanup */ + printk("KDB: Error, UHCI Keyboard HID won't work!\n"); + if (kdb_buffer) + usb_buffer_free(hid_inurb->dev, + usbhid_bufsize, kdb_buffer, + uhci_inbuf_dma); + + if (kdb_urb) + usb_free_urb(kdb_urb); + + return ret; +} +#endif + static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct hid_device *hid; @@ -1045,8 +1125,15 @@ static int hid_probe(struct usb_interfac int ret; struct usbhid_device *usbhid = hid->driver_data; extern void * usb_hcd_get_kdb_poll_func(struct usb_device *udev); - ret = kdb_usb_keyboard_attach(usbhid->urbin, usbhid->inbuf, - usb_hcd_get_kdb_poll_func(interface_to_usbdev(intf))); + extern void * usb_hcd_get_kdb_completion_func(struct usb_device *udev); + extern int usb_hcd_check_uhci(struct usb_device *udev); + + if (usb_hcd_check_uhci(interface_to_usbdev(intf))) + ret = kdb_uhci_submit_urb(intf, usbhid->bufsize, usbhid->urbin); + else + ret = kdb_usb_keyboard_attach(usbhid->urbin, usbhid->inbuf, + usb_hcd_get_kdb_poll_func(interface_to_usbdev(intf)), + usb_hcd_get_kdb_completion_func(interface_to_usbdev(intf))); if (ret == -1) printk(": FAILED to register keyboard (%s) " Index: linux-2.6.24-rc2/include/linux/kdb.h =================================================================== --- linux-2.6.24-rc2.orig/include/linux/kdb.h +++ linux-2.6.24-rc2/include/linux/kdb.h @@ -143,9 +143,17 @@ extern void smp_kdb_stop(void); #include <linux/usb.h> -extern int kdb_usb_keyboard_attach(struct urb *urb, unsigned char *buffer, void *poll_func); +extern int kdb_uhci_keyboard_urb(struct urb *urb); +extern int kdb_uhci_keyboard_clear(struct urb *urb); +extern int kdb_usb_keyboard_alloc(void); + +extern int kdb_usb_keyboard_attach(struct urb *urb, unsigned char *buffer, void *poll_func, void *compl_func); extern int kdb_usb_keyboard_detach(struct urb *urb); +extern int +kdb_usb_uhci_keyboard_attach(struct urb *urb, unsigned int usbhid_bufsize, + void *poll_func, void *compl_func); + #endif /* CONFIG_KDB_USB */ static inline Index: linux-2.6.24-rc2/drivers/usb/host/uhci-hcd.c =================================================================== --- linux-2.6.24-rc2.orig/drivers/usb/host/uhci-hcd.c +++ linux-2.6.24-rc2/drivers/usb/host/uhci-hcd.c @@ -50,6 +50,10 @@ #include "uhci-hcd.h" #include "pci-quirks.h" +#ifdef CONFIG_KDB_USB +#include <linux/kdb.h> +#endif + /* * Version Information */ @@ -430,6 +434,17 @@ static irqreturn_t uhci_irq(struct usb_h return IRQ_HANDLED; } +#ifdef CONFIG_KDB_USB +static int +uhci_kdb_poll_char(struct urb *urb) +{ + if (!urb) /* can happen if no keyboard attached */ + return -1; + + return uhci_check_kdb_uhci_qh(kdb_uhci_keyboard_get_qh(urb)); +} +#endif + /* * Store the current frame number in uhci->frame_number if the controller * is runnning. Expand from 11 bits (of which we use only 10) to a @@ -888,6 +903,10 @@ static const struct hc_driver uhci_drive .hub_status_data = uhci_hub_status_data, .hub_control = uhci_hub_control, +#ifdef CONFIG_KDB_USB + .kdb_poll_char = uhci_kdb_poll_char, + .kdb_completion = kdb_uhci_urb_complete, +#endif }; static const struct pci_device_id uhci_pci_ids[] = { { Index: linux-2.6.24-rc2/arch/x86/kdb/kdba_io_32.c =================================================================== --- linux-2.6.24-rc2.orig/arch/x86/kdb/kdba_io_32.c +++ linux-2.6.24-rc2/arch/x86/kdb/kdba_io_32.c @@ -55,12 +55,146 @@ static unsigned char kdb_usb_keycode[256 150,158,159,128,136,177,178,176,142,152,173,140 }; +/* Check if URB is managed by KDB code */ +int kdb_uhci_keyboard_urb(struct urb *urb) +{ + int i; + + for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) { + if (kdb_usb_kbds[i].urb && kdb_usb_kbds[i].urb == urb) + return i; + } + return -1; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_urb); + +/* Check if UHCI QH is managed by KDB code */ +int kdb_uhci_keyboard_chech_uhci_qh(struct uhci_qh *qh) +{ + int i; + + for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) { + if (kdb_usb_kbds[i].urb && kdb_usb_kbds[i].qh == qh) + return i; + } + return -1; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_chech_uhci_qh); + +/* Clear keyboar entry */ +int kdb_uhci_keyboard_clear(struct urb *urb) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + kdb_usb_kbds[i].urb = NULL; + kdb_usb_kbds[i].buffer = NULL; + kdb_usb_kbds[i].poll_func = NULL; + kdb_usb_kbds[i].urb_complete = NULL; + } + + return 0; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_clear); + +/* Set UHCI QH using URB pointer */ +int kdb_uhci_keyboard_set_qh(struct urb *urb, struct uhci_qh *qh) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + kdb_usb_kbds[i].qh = qh; + } + + return 0; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_set_qh); + +/* Get UHCI QH using URB pointer */ +struct uhci_qh *kdb_uhci_keyboard_get_qh(struct urb *urb) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + return kdb_usb_kbds[i].qh; + } + + return NULL; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_get_qh); + +/* Set UHCI hid_event using URB pointer */ +int kdb_uhci_keyboard_set_hid_event(struct urb *urb, int hid_event) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + kdb_usb_kbds[i].kdb_hid_event = hid_event; + } + + return 0; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_set_hid_event); + +/* Get UHCI hid_event using URB pointer */ +int kdb_uhci_keyboard_get_hid_event(struct urb *urb) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + return kdb_usb_kbds[i].kdb_hid_event; + } + + return 0; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_get_hid_event); + +/* Set UHCI hid_event using UHCI QH pointer */ +int kdb_uhci_keyboard_set_hid_event_qh(struct uhci_qh *qh, int hid_event) +{ + int i; + + for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) { + if (kdb_usb_kbds[i].urb && kdb_usb_kbds[i].qh == qh){ + kdb_usb_kbds[i].kdb_hid_event = hid_event; + return i; + } + } + return -1; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_set_hid_event_qh); + +/* Get UHCI hid_event using UHCI QH pointer */ +int kdb_uhci_keyboard_get_hid_event_qh(struct uhci_qh *qh) +{ + int i; + + for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) { + if (kdb_usb_kbds[i].urb && kdb_usb_kbds[i].qh == qh) + return kdb_usb_kbds[i].kdb_hid_event; + } + + return -1; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_get_hid_event_qh); + /* * kdb_usb_keyboard_attach() * Attach a USB keyboard to kdb. */ int -kdb_usb_keyboard_attach(struct urb *urb, unsigned char *buffer, void *poll_func) +kdb_usb_keyboard_attach(struct urb *urb, unsigned char *buffer, + void *poll_func, void *compl_func) { int i; int rc = -1; @@ -82,6 +216,7 @@ kdb_usb_keyboard_attach(struct urb *urb, kdb_usb_kbds[i].urb = urb; kdb_usb_kbds[i].buffer = buffer; kdb_usb_kbds[i].poll_func = poll_func; + kdb_usb_kbds[i].urb_complete = compl_func; rc = 0; /* success */ @@ -142,6 +277,9 @@ get_usb_char(void) int ret; unsigned char keycode, spec; extern u_short plain_map[], shift_map[], ctrl_map[]; + int poll_ret, i2, j, max; + + ret = -1; if (kdb_no_usb) return -1; @@ -158,20 +296,27 @@ get_usb_char(void) continue; /* Transfer char */ - ret = (*kdb_usb_kbds[i].poll_func)(kdb_usb_kbds[i].urb); - if (ret == -1) /* error or no characters, try the next kbd */ + poll_ret = (*kdb_usb_kbds[i].poll_func)(kdb_usb_kbds[i].urb); + if (poll_ret == -1) /* error or no characters, try the next kbd */ continue; + /* If 2 keys was pressed simultaneously, + * both keycodes will be in buffer. + * Last pressed key will be last non + * zero byte. + */ + for (j=0; j<4; j++){ + if (!kdb_usb_kbds[i].buffer[2+j]) + break; + } + /* Last pressed key */ + max = j + 1; + spec = kdb_usb_kbds[i].buffer[0]; - keycode = kdb_usb_kbds[i].buffer[2]; + keycode = kdb_usb_kbds[i].buffer[max]; kdb_usb_kbds[i].buffer[0] = (char)0; kdb_usb_kbds[i].buffer[2] = (char)0; - if(kdb_usb_kbds[i].buffer[3]) { - kdb_usb_kbds[i].buffer[3] = (char)0; - continue; - } - /* A normal key is pressed, decode it */ if(keycode) keycode = kdb_usb_keycode[keycode]; @@ -182,10 +327,12 @@ get_usb_char(void) { case 0x2: case 0x20: /* Shift */ - return shift_map[keycode]; + ret = shift_map[keycode]; + break; case 0x1: case 0x10: /* Ctrl */ - return ctrl_map[keycode]; + ret = ctrl_map[keycode]; + break; case 0x4: case 0x40: /* Alt */ break; @@ -194,31 +341,45 @@ get_usb_char(void) switch(keycode) { case 0x1C: /* Enter */ - return 13; - + ret = 13; + break; case 0x3A: /* Capslock */ kdb_usb_kbds[i].caps_lock = !(kdb_usb_kbds[i].caps_lock); break; case 0x0E: /* Backspace */ - return 8; + ret = 8; + break; case 0x0F: /* TAB */ - return 9; + ret = 9; + break; case 0x77: /* Pause */ break ; default: if(!kdb_usb_kbds[i].caps_lock) { - return plain_map[keycode]; + ret = plain_map[keycode]; + break; } else { - return shift_map[keycode]; + ret = shift_map[keycode]; + break; } } } + /* Key was pressed, return keycode */ + break; } - /* no chars were returned from any of the USB keyboards */ + for(i2=0; i2<8; i2++){ + if (kdb_usb_kbds[i2].buffer) + for(j=0; j<8; j++){ + kdb_usb_kbds[i2].buffer[j] = (char)0; + } + } + + if (kdb_usb_kbds[i].urb_complete) + (*kdb_usb_kbds[i].urb_complete)((struct urb *)kdb_usb_kbds[i].urb); - return -1; + return ret; } #endif /* CONFIG_KDB_USB */ Index: linux-2.6.24-rc2/arch/x86/kdb/kdba_io_64.c =================================================================== --- linux-2.6.24-rc2.orig/arch/x86/kdb/kdba_io_64.c +++ linux-2.6.24-rc2/arch/x86/kdb/kdba_io_64.c @@ -55,12 +55,146 @@ static unsigned char kdb_usb_keycode[256 150,158,159,128,136,177,178,176,142,152,173,140 }; +/* Check if URB is managed by KDB code */ +int kdb_uhci_keyboard_urb(struct urb *urb) +{ + int i; + + for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) { + if (kdb_usb_kbds[i].urb && kdb_usb_kbds[i].urb == urb) + return i; + } + return -1; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_urb); + +/* Check if UHCI QH is managed by KDB code */ +int kdb_uhci_keyboard_chech_uhci_qh(struct uhci_qh *qh) +{ + int i; + + for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) { + if (kdb_usb_kbds[i].urb && kdb_usb_kbds[i].qh == qh) + return i; + } + return -1; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_chech_uhci_qh); + +/* Clear keyboar entry */ +int kdb_uhci_keyboard_clear(struct urb *urb) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + kdb_usb_kbds[i].urb = NULL; + kdb_usb_kbds[i].buffer = NULL; + kdb_usb_kbds[i].poll_func = NULL; + kdb_usb_kbds[i].urb_complete = NULL; + } + + return 0; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_clear); + +/* Set UHCI QH using URB pointer */ +int kdb_uhci_keyboard_set_qh(struct urb *urb, struct uhci_qh *qh) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + kdb_usb_kbds[i].qh = qh; + } + + return 0; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_set_qh); + +/* Get UHCI QH using URB pointer */ +struct uhci_qh *kdb_uhci_keyboard_get_qh(struct urb *urb) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + return kdb_usb_kbds[i].qh; + } + + return NULL; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_get_qh); + +/* Set UHCI hid_event using URB pointer */ +int kdb_uhci_keyboard_set_hid_event(struct urb *urb, int hid_event) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + kdb_usb_kbds[i].kdb_hid_event = hid_event; + } + + return 0; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_set_hid_event); + +/* Get UHCI hid_event using URB pointer */ +int kdb_uhci_keyboard_get_hid_event(struct urb *urb) +{ + int i; + + i = kdb_uhci_keyboard_urb(urb); + if (i != -1){ + /* found a free array index */ + return kdb_usb_kbds[i].kdb_hid_event; + } + + return 0; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_get_hid_event); + +/* Set UHCI hid_event using UHCI QH pointer */ +int kdb_uhci_keyboard_set_hid_event_qh(struct uhci_qh *qh, int hid_event) +{ + int i; + + for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) { + if (kdb_usb_kbds[i].urb && kdb_usb_kbds[i].qh == qh){ + kdb_usb_kbds[i].kdb_hid_event = hid_event; + return i; + } + } + return -1; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_set_hid_event_qh); + +/* Get UHCI hid_event using UHCI QH pointer */ +int kdb_uhci_keyboard_get_hid_event_qh(struct uhci_qh *qh) +{ + int i; + + for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) { + if (kdb_usb_kbds[i].urb && kdb_usb_kbds[i].qh == qh) + return kdb_usb_kbds[i].kdb_hid_event; + } + + return -1; +} +EXPORT_SYMBOL_GPL (kdb_uhci_keyboard_get_hid_event_qh); + /* * kdb_usb_keyboard_attach() * Attach a USB keyboard to kdb. */ int -kdb_usb_keyboard_attach(struct urb *urb, unsigned char *buffer, void *poll_func) +kdb_usb_keyboard_attach(struct urb *urb, unsigned char *buffer, + void *poll_func, void *compl_func) { int i; int rc = -1; @@ -82,6 +216,7 @@ kdb_usb_keyboard_attach(struct urb *urb, kdb_usb_kbds[i].urb = urb; kdb_usb_kbds[i].buffer = buffer; kdb_usb_kbds[i].poll_func = poll_func; + kdb_usb_kbds[i].urb_complete = compl_func; rc = 0; /* success */ @@ -142,6 +277,9 @@ get_usb_char(void) int ret; unsigned char keycode, spec; extern u_short plain_map[], shift_map[], ctrl_map[]; + int poll_ret, i2, j, max; + + ret = -1; if (kdb_no_usb) return -1; @@ -158,20 +296,27 @@ get_usb_char(void) continue; /* Transfer char */ - ret = (*kdb_usb_kbds[i].poll_func)(kdb_usb_kbds[i].urb); - if (ret == -1) /* error or no characters, try the next kbd */ + poll_ret = (*kdb_usb_kbds[i].poll_func)(kdb_usb_kbds[i].urb); + if (poll_ret == -1) /* error or no characters, try the next kbd */ continue; + /* If 2 keys was pressed simultaneously, + * both keycodes will be in buffer. + * Last pressed key will be last non + * zero byte. + */ + for (j=0; j<4; j++){ + if (!kdb_usb_kbds[i].buffer[2+j]) + break; + } + /* Last pressed key */ + max = j + 1; + spec = kdb_usb_kbds[i].buffer[0]; - keycode = kdb_usb_kbds[i].buffer[2]; + keycode = kdb_usb_kbds[i].buffer[max]; kdb_usb_kbds[i].buffer[0] = (char)0; kdb_usb_kbds[i].buffer[2] = (char)0; - if(kdb_usb_kbds[i].buffer[3]) { - kdb_usb_kbds[i].buffer[3] = (char)0; - continue; - } - /* A normal key is pressed, decode it */ if(keycode) keycode = kdb_usb_keycode[keycode]; @@ -182,10 +327,12 @@ get_usb_char(void) { case 0x2: case 0x20: /* Shift */ - return shift_map[keycode]; + ret = shift_map[keycode]; + break; case 0x1: case 0x10: /* Ctrl */ - return ctrl_map[keycode]; + ret = ctrl_map[keycode]; + break; case 0x4: case 0x40: /* Alt */ break; @@ -194,31 +341,45 @@ get_usb_char(void) switch(keycode) { case 0x1C: /* Enter */ - return 13; - + ret = 13; + break; case 0x3A: /* Capslock */ kdb_usb_kbds[i].caps_lock = !(kdb_usb_kbds[i].caps_lock); break; case 0x0E: /* Backspace */ - return 8; + ret = 8; + break; case 0x0F: /* TAB */ - return 9; + ret = 9; + break; case 0x77: /* Pause */ break ; default: if(!kdb_usb_kbds[i].caps_lock) { - return plain_map[keycode]; + ret = plain_map[keycode]; + break; } else { - return shift_map[keycode]; + ret = shift_map[keycode]; + break; } } } + /* Key was pressed, return keycode */ + break; } - /* no chars were returned from any of the USB keyboards */ + for(i2=0; i2<8; i2++){ + if (kdb_usb_kbds[i2].buffer) + for(j=0; j<8; j++){ + kdb_usb_kbds[i2].buffer[j] = (char)0; + } + } + + if (kdb_usb_kbds[i].urb_complete) + (*kdb_usb_kbds[i].urb_complete)((struct urb *)kdb_usb_kbds[i].urb); - return -1; + return ret; } #endif /* CONFIG_KDB_USB */ Index: linux-2.6.24-rc2/include/linux/kdbprivate.h =================================================================== --- linux-2.6.24-rc2.orig/include/linux/kdbprivate.h +++ linux-2.6.24-rc2/include/linux/kdbprivate.h @@ -489,7 +489,10 @@ struct kdb_usb_kbd_info { struct urb *urb; /* pointer to the URB */ unsigned char *buffer; /* pointer to the kbd char buffer */ int (*poll_func)(struct urb *urb); /* poll function to retrieve chars */ + int (*urb_complete)(struct urb *urb); /* called when URB int is processed */ int caps_lock; /* state of the caps lock for this keyboard */ + struct uhci_qh *qh; + int kdb_hid_event; }; #endif /* CONFIG_KDB_USB */ Index: linux-2.6.24-rc2/drivers/usb/core/hcd.c =================================================================== --- linux-2.6.24-rc2.orig/drivers/usb/core/hcd.c +++ linux-2.6.24-rc2/drivers/usb/core/hcd.c @@ -1851,6 +1851,32 @@ usb_hcd_get_kdb_poll_func(struct usb_dev return NULL; } EXPORT_SYMBOL_GPL (usb_hcd_get_kdb_poll_func); + +void * +usb_hcd_get_kdb_completion_func(struct usb_device *udev) +{ + struct usb_hcd *hcd = bus_to_hcd(udev->bus); + + if (hcd && hcd->driver) + return (void *)(hcd->driver->kdb_completion); + + return NULL; +} +EXPORT_SYMBOL_GPL (usb_hcd_get_kdb_completion_func); + +int +usb_hcd_check_uhci(struct usb_device *udev) +{ + struct usb_hcd *hcd = bus_to_hcd(udev->bus); + + if (hcd && hcd->driver){ + if (!(strcmp(hcd->driver->description, "uhci_hcd"))) + return 1; + } + + return 0; +} +EXPORT_SYMBOL_GPL (usb_hcd_check_uhci); #endif /* CONFIG_KDB_USB */ /*-------------------------------------------------------------------------*/ Index: linux-2.6.24-rc2/drivers/usb/core/hcd.h =================================================================== --- linux-2.6.24-rc2.orig/drivers/usb/core/hcd.h +++ linux-2.6.24-rc2/drivers/usb/core/hcd.h @@ -213,6 +213,7 @@ struct hc_driver { #ifdef CONFIG_KDB_USB /* KDB poll function for this HC */ int (*kdb_poll_char)(struct urb *urb); + void (*kdb_completion)(struct urb *urb); #endif /* CONFIG_KDB_USB */ }; --------------------------- Use http://oss.sgi.com/ecartis to modify your settings or to unsubscribe.