Subversion Repositories Kolibri OS

Rev

Rev 1613 | 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
    };
124
    td->status = TD_CTRL_ACTIVE | TD_CTRL_IOC | dev->speed;
1605 serge 125
    td->token ^= DATA1;
1029 serge 126
127
 
1613 serge 128
      list_add_tail(&rq->list, &dev->host->rq_list);
129
      qh = dev->host->qh[rq->qnum];
1875 serge 130
      qh->qelem = rq->td_head->dma;
1613 serge 131
      mb();
132
    safe_sti(efl);
133
134
 
1600 serge 135
};
1029 serge 136
137
 
1875 serge 138
{
139
    uint16_t value;
140
    struct
141
    {
142
        uint8_t code;
143
        uint8_t ecode;
144
    };
145
}scancode_t;
146
147
 
148
{
149
  /*   0       1       2       3       4       5       6       7    */
150
  /*   8       9       A       B       C       D       E       F    */
151
152
 
153
    0x0012, 0x0021, 0x0022, 0x0023, 0x0017, 0x0024, 0x0025, 0x0026,
154
155
 
156
    0x0016, 0x002F, 0x0011, 0x002D, 0x0015, 0x002C, 0x0002, 0x0003,
157
158
 
159
    0x001C, 0x0001, 0x000E, 0x000F, 0x0039, 0x000C, 0x000D, 0x001A,
160
161
 
162
    0x0035, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040,
163
164
 
165
    0x0000, 0xE052, 0xE047, 0xE049, 0xE053, 0xE04F, 0xE051, 0xE04D,
166
167
 
168
    0xE01C, 0x004F, 0x0050, 0x0051, 0x004B, 0x004C, 0x004D, 0x0047,
169
170
 
171
    0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B,
172
173
 
174
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
175
176
 
177
    0x0070, 0x007D, 0x0079, 0x007B, 0x005C, 0x0000, 0x0000, 0x0000,
178
179
 
180
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
181
182
 
183
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
184
185
 
186
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
187
188
 
189
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
190
191
 
192
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
193
194
 
195
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
196
197
 
198
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
199
200
 
201
202
 
203
204
 
205
{
206
    td_t   *td;
207
    qh_t   *qh;
208
209
 
210
    int    i;
211
212
 
213
214
 
215
    {
216
        uint8_t action;
217
        scancode_t scan;
218
219
 
220
221
 
222
223
 
224
        {
225
            if(action & 1)
226
            {
227
                scan.value = usb_keycode[i+224];
228
229
 
230
                {
231
                    if(scan.ecode)
232
                        SetKeyboardData(scan.ecode);
233
                    SetKeyboardData(scan.code);
234
                }
235
                else
236
                {
237
                    if(scan.ecode)
238
                        SetKeyboardData(scan.ecode);
239
                    SetKeyboardData(scan.code|0x80);
240
                };
241
            }
242
            action >>= 1;
243
        }
244
245
 
246
 
247
        {
248
            if ((kbd_old[i] > 3) && (memscan(data+2, kbd_old[i], 6) == data+8))
249
            {
250
                scan.value = usb_keycode[kbd_old[i]];
251
252
 
253
                {
254
                    if(scan.ecode)
255
                        SetKeyboardData(scan.ecode);
256
                    SetKeyboardData(scan.code|0x80);
257
                  //  input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
258
                }
259
                else
260
                    dbgprintf("Unknown key (scancode %#x) released.\n", kbd_old[i]);
261
            }
262
263
 
264
            {
265
                scan.value = usb_keycode[data[i]];
266
267
 
268
                {
269
                    if(scan.ecode)
270
                        SetKeyboardData(scan.ecode);
271
                    SetKeyboardData(scan.code);
272
                   //input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
273
                }
274
                else
275
                    dbgprintf("Unknown key (scancode %#x) released.\n", data[i]);
276
            }
277
        }
278
        memcpy(kbd_old, data, 8);
279
    };
280
281
 
282
    td->token ^= DATA1;
283
284
 
285
      list_add_tail(&rq->list, &dev->host->rq_list);
286
      qh = dev->host->qh[rq->qnum];
287
      qh->qelem = rq->td_head->dma;
288
      mb();
289
    safe_sti(efl);
290
291
 
292
};
293
294
 
1029 serge 295
{
296
    request_t *rq;
297
    endp_t    enp;
298
299
 
300
    addr_t  size;
301
    u32_t   toggle;
302
303
 
304
305
 
306
            req_set_conf[4]  = {0x0900,0x0001,0x0000,0x0000};
307
308
 
309
        return;
310
311
 
312
    enp.size    = en_d->wMaxPacketSize;
313
    enp.toggle  = DATA0;
314
315
 
1875 serge 316
1029 serge 317
 
1605 serge 318
    rq->handler = &mouse_handler;
1029 serge 319
320
 
1613 serge 321
      list_add_tail(&rq->list, &dev->host->rq_list);
322
      qh = dev->host->qh[rq->qnum];
1875 serge 323
      qh->qelem = rq->td_head->dma;
1613 serge 324
      mb();
325
    safe_sti(efl);
326
1029 serge 327
 
1875 serge 328
}
1029 serge 329
1875 serge 330
 
331
{
332
    request_t *rq;
333
    endp_t    enp;
334
335
 
336
    addr_t  size;
337
    u32_t   toggle;
338
339
 
340
341
 
342
            req_set_conf[4]  = {0x0900,0x0001,0x0000,0x0000};
343
344
 
345
        return;
346
347
 
348
    enp.size    = en_d->wMaxPacketSize;
349
    enp.toggle  = DATA0;
350
351
 
352
353
 
354
    rq->handler = &keyboard_handler;
355
356
 
357
      list_add_tail(&rq->list, &dev->host->rq_list);
358
      qh = dev->host->qh[rq->qnum];
359
      qh->qelem = rq->td_head->dma;
360
      mb();
361
    safe_sti(efl);
362
363
 
364
}
365
366
 
367
{
368
    if (!size)
369
        return addr;
370
    __asm__ __volatile__(
371
        "repnz; scasb       \n\t"
372
        "jnz 1f             \n\t"
373
        "dec %%edi          \n\t"
374
    "1:"
375
        : "=D" (addr), "=c" (size)
376
        : "D" (addr), "1" (size), "a" (c)
377
        : "memory");
378
    return addr;
379
}
380