Subversion Repositories Kolibri OS

Rev

Rev 1875 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1029 serge 1
 
2
    u8_t   bDescriptorType;
3
    u16_t  wDescriptorLength;
4
} __attribute__ ((packed));
5
6
 
7
    u8_t   bLength;
8
    u8_t   bDescriptorType;
9
    u16_t  bcdHID;
10
    u8_t   bCountryCode;
11
    u8_t   bNumDescriptors;
12
13
 
14
} __attribute__ ((packed));
15
16
 
17
void create_hid_keyboard(udev_t *dev, endpoint_descr_t *en_d);
1875 serge 18
1029 serge 19
 
1600 serge 20
{
1029 serge 21
    interface_descr_t              *interface;
22
    struct hid_descriptor          *hds;
23
    struct hid_class_descriptor    *hidclass;
24
    u8_t *dptr = (u8_t*)dev->conf;
25
26
 
27
28
 
29
30
 
31
32
 
33
  //  {
34
        interface = (interface_descr_t*)dptr;
35
        dptr+= interface->bLength;
36
37
 
38
                  "bLength             %d\n"
39
                  "bDescriptorType     %d\n"
40
                  "bInterfaceNumber    %d\n"
41
                  "bAlternateSetting   %d\n"
42
                  "bNumEndpoints       %d\n"
43
                  "bInterfaceClass     %d\n"
44
                  "bInterfaceSubClass  %d\n"
45
                  "bInterfaceProtocol  %d\n"
46
                  "iInterface          %d\n\n",
47
                  i+1,
48
                  interface->bLength,
49
                  interface->bDescriptorType,
50
                  interface->bInterfaceNumber,
51
                  interface->bAlternateSetting,
52
                  interface->bNumEndpoints,
53
                  interface->bInterfaceClass,
54
                  interface->bInterfaceSubClass,
55
                  interface->bInterfaceProtocol,
56
                  interface->iInterface);
57
58
 
59
60
 
61
                  "bLength             %d\n"
62
                  "bDescriptorType     %d\n"
63
                  "bcdHID              %x\n"
64
                  "bCountryCode        %d\n"
65
                  "bNumDescriptors     %d\n",
66
                  hds->bLength,
67
                  hds->bDescriptorType,
68
                  hds->bcdHID,
69
                  hds->bCountryCode,
70
                  hds->bNumDescriptors);
71
72
 
73
        {
74
            dbgprintf("bDescriptorType    %d\n"
75
                      "wDescriptorLength  %d\n",
76
                      hds->desc[j].bDescriptorType,
77
                      hds->desc[j].wDescriptorLength);
78
        };
79
        dptr+= hds->bLength;
80
81
 
82
        ep = (endpoint_descr_t*)dptr;
83
84
 
85
                  "bLength             %d\n"
86
                  "bDescriptorType     %d\n"
87
                  "bEndpointAddress    %d\n"
88
                  "bmAttributes        %d\n"
89
                  "wMaxPacketSize      %d\n"
90
                  "bInterval           %d\n",
91
                  ep->bLength, ep->bDescriptorType,
92
                  ep->bEndpointAddress, ep->bmAttributes,
93
                  ep->wMaxPacketSize, ep->bInterval);
94
        dptr+= ep->bLength;
95
96
 
1875 serge 97
        {
98
            case 1:
99
                create_hid_keyboard(dev, ep);
100
                break;
101
102
 
103
                create_hid_mouse(dev, ep);
104
                break;
105
        }
106
  //  }
1029 serge 107
    return true;
1600 serge 108
};
1029 serge 109
110
 
111
 
1600 serge 112
{
1029 serge 113
    td_t   *td;
114
    qh_t   *qh;
1613 serge 115
1029 serge 116
 
117
118
 
119
    {
120
        struct boot_packet *pkt;
121
        pkt = (struct boot_packet *)rq->data;
122
        SetMouseData(pkt->buttons, pkt->x, -pkt->y, -pkt->z, 0);
123
        memset(pkt,0, sizeof(*pkt));
2111 serge 124
    };
1029 serge 125
    td->status = TD_CTRL_ACTIVE | TD_CTRL_IOC | dev->speed;
1605 serge 126
    td->token ^= DATA1;
1029 serge 127
128
 
1613 serge 129
      list_add_tail(&rq->list, &dev->host->rq_list);
130
      qh = dev->host->qh[rq->qnum];
1875 serge 131
      qh->qelem = rq->td_head->dma;
1613 serge 132
      mb();
133
    safe_sti(efl);
134
135
 
1600 serge 136
};
1029 serge 137
138
 
1875 serge 139
{
140
    uint16_t value;
141
    struct
142
    {
143
        uint8_t code;
144
        uint8_t ecode;
145
    };
146
}scancode_t;
147
148
 
149
{
150
  /*   0       1       2       3       4       5       6       7    */
151
  /*   8       9       A       B       C       D       E       F    */
152
153
 
154
    0x0012, 0x0021, 0x0022, 0x0023, 0x0017, 0x0024, 0x0025, 0x0026,
155
156
 
157
    0x0016, 0x002F, 0x0011, 0x002D, 0x0015, 0x002C, 0x0002, 0x0003,
158
159
 
160
    0x001C, 0x0001, 0x000E, 0x000F, 0x0039, 0x000C, 0x000D, 0x001A,
161
162
 
163
    0x0035, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040,
164
165
 
166
    0x0000, 0xE052, 0xE047, 0xE049, 0xE053, 0xE04F, 0xE051, 0xE04D,
167
168
 
169
    0xE01C, 0x004F, 0x0050, 0x0051, 0x004B, 0x004C, 0x004D, 0x0047,
170
171
 
172
    0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B,
173
174
 
175
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
176
177
 
178
    0x0070, 0x007D, 0x0079, 0x007B, 0x005C, 0x0000, 0x0000, 0x0000,
179
180
 
181
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
182
183
 
184
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
185
186
 
187
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
188
189
 
190
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
191
192
 
193
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
194
195
 
196
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
197
198
 
199
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
200
201
 
202
203
 
204
205
 
206
{
207
    td_t   *td;
208
    qh_t   *qh;
209
210
 
211
    int    i;
212
213
 
214
215
 
216
    {
217
        uint8_t action;
218
        scancode_t scan;
219
220
 
221
222
 
223
224
 
225
        {
226
            if(action & 1)
227
            {
228
                scan.value = usb_keycode[i+224];
229
230
 
231
                {
232
                    if(scan.ecode)
233
                        SetKeyboardData(scan.ecode);
234
                    SetKeyboardData(scan.code);
235
                }
236
                else
237
                {
238
                    if(scan.ecode)
239
                        SetKeyboardData(scan.ecode);
240
                    SetKeyboardData(scan.code|0x80);
241
                };
242
            }
243
            action >>= 1;
244
        }
245
246
 
247
 
248
        {
249
            if ((kbd_old[i] > 3) && (memscan(data+2, kbd_old[i], 6) == data+8))
250
            {
251
                scan.value = usb_keycode[kbd_old[i]];
252
253
 
254
                {
255
                    if(scan.ecode)
256
                        SetKeyboardData(scan.ecode);
257
                    SetKeyboardData(scan.code|0x80);
258
                  //  input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
259
                }
260
                else
261
                    dbgprintf("Unknown key (scancode %#x) released.\n", kbd_old[i]);
262
            }
263
264
 
265
            {
266
                scan.value = usb_keycode[data[i]];
267
268
 
269
                {
270
                    if(scan.ecode)
271
                        SetKeyboardData(scan.ecode);
272
                    SetKeyboardData(scan.code);
273
                   //input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
274
                }
275
                else
276
                    dbgprintf("Unknown key (scancode %#x) released.\n", data[i]);
277
            }
278
        }
279
        memcpy(kbd_old, data, 8);
280
    };
281
282
 
283
    td->token ^= DATA1;
284
285
 
286
      list_add_tail(&rq->list, &dev->host->rq_list);
287
      qh = dev->host->qh[rq->qnum];
288
      qh->qelem = rq->td_head->dma;
289
      mb();
290
    safe_sti(efl);
291
292
 
293
};
294
295
 
1029 serge 296
{
297
    request_t *rq;
298
    endp_t    enp;
299
300
 
301
    addr_t  size;
302
    u32_t   toggle;
303
304
 
305
306
 
307
            req_set_conf[4]  = {0x0900,0x0001,0x0000,0x0000};
308
309
 
310
        return;
311
312
 
313
    enp.size    = en_d->wMaxPacketSize;
314
    enp.toggle  = DATA0;
315
316
 
1875 serge 317
1029 serge 318
 
1605 serge 319
    rq->handler = &mouse_handler;
1029 serge 320
321
 
1613 serge 322
      list_add_tail(&rq->list, &dev->host->rq_list);
323
      qh = dev->host->qh[rq->qnum];
1875 serge 324
      qh->qelem = rq->td_head->dma;
1613 serge 325
      mb();
326
    safe_sti(efl);
327
1029 serge 328
 
1875 serge 329
}
1029 serge 330
1875 serge 331
 
332
{
333
    request_t *rq;
334
    endp_t    enp;
335
336
 
337
    addr_t  size;
338
    u32_t   toggle;
339
340
 
341
342
 
343
            req_set_conf[4]  = {0x0900,0x0001,0x0000,0x0000};
344
345
 
346
        return;
347
348
 
349
    enp.size    = en_d->wMaxPacketSize;
350
    enp.toggle  = DATA0;
351
352
 
353
354
 
355
    rq->handler = &keyboard_handler;
356
357
 
358
      list_add_tail(&rq->list, &dev->host->rq_list);
359
      qh = dev->host->qh[rq->qnum];
360
      qh->qelem = rq->td_head->dma;
361
      mb();
362
    safe_sti(efl);
363
364
 
365
}
366
367
 
368
{
369
    if (!size)
370
        return addr;
371
    __asm__ __volatile__(
372
        "repnz; scasb       \n\t"
373
        "jnz 1f             \n\t"
374
        "dec %%edi          \n\t"
375
    "1:"
376
        : "=D" (addr), "=c" (size)
377
        : "D" (addr), "1" (size), "a" (c)
378
        : "memory");
379
    return addr;
380
}
381