Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* HID support for Linux

2

* HID support for Linux

3

*

3

*

4

5

6

7

8

*/

8

*/

9

10

/*

10

/*

11

* This program is free software; you can redistribute it and/or modify it

11

* This program is free software; you can redistribute it and/or modify it

12

* under the terms of the GNU General Public License as published by the Free

12

* under the terms of the GNU General Public License as published by the Free

13

* Software Foundation; either version 2 of the License, or (at your option)

13

* Software Foundation; either version 2 of the License, or (at your option)

14

* any later version.

14

* any later version.

15

*/

15

*/

16

17

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

17

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

18

19

#include <linux/module.h>

19

#include <linux/module.h>

20

#include <linux/slab.h>

20

#include <linux/slab.h>

21

#include <linux/init.h>

21

#include <linux/init.h>

22

#include <linux/kernel.h>

22

#include <linux/kernel.h>

23

#include <linux/list.h>

23

#include <linux/list.h>

24

#include <linux/mm.h>

24

#include <linux/mm.h>

25

#include <linux/spinlock.h>

25

#include <linux/spinlock.h>

26

#include <asm/unaligned.h>

26

#include <asm/unaligned.h>

27

#include <asm/byteorder.h>

27

#include <asm/byteorder.h>

28

#include <linux/input.h>

28

#include <linux/input.h>

29

#include <linux/wait.h>

29

#include <linux/wait.h>

30

#include <linux/vmalloc.h>

30

#include <linux/vmalloc.h>

31

#include <linux/sched.h>

31

#include <linux/sched.h>

32

#include <linux/semaphore.h>

32

#include <linux/semaphore.h>

33

34

#include <linux/hid.h>

34

#include <linux/hid.h>

35

#include <linux/hiddev.h>

35

#include <linux/hiddev.h>

36

#include <linux/hid-debug.h>

36

#include <linux/hid-debug.h>

37

#include <linux/hidraw.h>

37

#include <linux/hidraw.h>

38

39

#include "hid-ids.h"

39

#include "hid-ids.h"

40

41

/*

41

/*

42

* Version Information

42

* Version Information

43

*/

43

*/

44

45

#define DRIVER_DESC "HID core driver"

45

#define DRIVER_DESC "HID core driver"

46

#define DRIVER_LICENSE "GPL"

46

#define DRIVER_LICENSE "GPL"

47

48

int hid_debug = 0;

48

int hid_debug = 0;

49

module_param_named(debug, hid_debug, int, 0600);

49

module_param_named(debug, hid_debug, int, 0600);

50

MODULE_PARM_DESC(debug, "toggle HID debugging messages");

50

MODULE_PARM_DESC(debug, "toggle HID debugging messages");

51

EXPORT_SYMBOL_GPL(hid_debug);

51

EXPORT_SYMBOL_GPL(hid_debug);

52

53

static int hid_ignore_special_drivers = 0;

53

static int hid_ignore_special_drivers = 0;

54

module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600);

54

module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600);

55

MODULE_PARM_DESC(debug, "Ignore any special drivers and handle all devices by generic driver");

55

MODULE_PARM_DESC(debug, "Ignore any special drivers and handle all devices by generic driver");

56

57

/*

57

/*

58

* Register a new report for a device.

58

* Register a new report for a device.

59

*/

59

*/

60

61

struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)

61

struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)

62

{

62

{

63

struct hid_report_enum *report_enum = device->report_enum + type;

63

struct hid_report_enum *report_enum = device->report_enum + type;

64

struct hid_report *report;

64

struct hid_report *report;

65

66

if (report_enum->report_id_hash[id])

66

if (report_enum->report_id_hash[id])

67

return report_enum->report_id_hash[id];

67

return report_enum->report_id_hash[id];

68

69

report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);

69

report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);

70

if (!report)

70

if (!report)

71

return NULL;

71

return NULL;

72

73

if (id != 0)

73

if (id != 0)

74

report_enum->numbered = 1;

74

report_enum->numbered = 1;

75

76

report->id = id;

76

report->id = id;

77

report->type = type;

77

report->type = type;

78

report->size = 0;

78

report->size = 0;

79

report->device = device;

79

report->device = device;

80

report_enum->report_id_hash[id] = report;

80

report_enum->report_id_hash[id] = report;

81

82

list_add_tail(&report->list, &report_enum->report_list);

82

list_add_tail(&report->list, &report_enum->report_list);

83

84

return report;

84

return report;

85

}

85

}

86

EXPORT_SYMBOL_GPL(hid_register_report);

86

EXPORT_SYMBOL_GPL(hid_register_report);

87

88

/*

88

/*

89

* Register a new field for this report.

89

* Register a new field for this report.

90

*/

90

*/

91

92

static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)

92

static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)

93

{

93

{

94

struct hid_field *field;

94

struct hid_field *field;

95

96

if (report->maxfield == HID_MAX_FIELDS) {

96

if (report->maxfield == HID_MAX_FIELDS) {

97

hid_err(report->device, "too many fields in report\n");

97

hid_err(report->device, "too many fields in report\n");

98

return NULL;

98

return NULL;

99

}

99

}

100

101

field = kzalloc((sizeof(struct hid_field) +

101

field = kzalloc((sizeof(struct hid_field) +

102

usages * sizeof(struct hid_usage) +

102

usages * sizeof(struct hid_usage) +

103

values * sizeof(unsigned)), GFP_KERNEL);

103

values * sizeof(unsigned)), GFP_KERNEL);

104

if (!field)

104

if (!field)

105

return NULL;

105

return NULL;

106

107

field->index = report->maxfield++;

107

field->index = report->maxfield++;

108

report->field[field->index] = field;

108

report->field[field->index] = field;

109

field->usage = (struct hid_usage *)(field + 1);

109

field->usage = (struct hid_usage *)(field + 1);

110

field->value = (s32 *)(field->usage + usages);

110

field->value = (s32 *)(field->usage + usages);

111

field->report = report;

111

field->report = report;

112

113

return field;

113

return field;

114

}

114

}

115

116

/*

116

/*

117

* Open a collection. The type/usage is pushed on the stack.

117

* Open a collection. The type/usage is pushed on the stack.

118

*/

118

*/

119

120

static int open_collection(struct hid_parser *parser, unsigned type)

120

static int open_collection(struct hid_parser *parser, unsigned type)

121

{

121

{

122

struct hid_collection *collection;

122

struct hid_collection *collection;

123

unsigned usage;

123

unsigned usage;

124

125

usage = parser->local.usage[0];

125

usage = parser->local.usage[0];

126

127

if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {

127

if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {

128

hid_err(parser->device, "collection stack overflow\n");

128

hid_err(parser->device, "collection stack overflow\n");

129

return -1;

129

return -1;

130

}

130

}

131

132

if (parser->device->maxcollection == parser->device->collection_size) {

132

if (parser->device->maxcollection == parser->device->collection_size) {

133

collection = kmalloc(sizeof(struct hid_collection) *

133

collection = kmalloc(sizeof(struct hid_collection) *

134

parser->device->collection_size * 2, GFP_KERNEL);

134

parser->device->collection_size * 2, GFP_KERNEL);

135

if (collection == NULL) {

135

if (collection == NULL) {

136

hid_err(parser->device, "failed to reallocate collection array\n");

136

hid_err(parser->device, "failed to reallocate collection array\n");

137

return -1;

137

return -1;

138

}

138

}

139

memcpy(collection, parser->device->collection,

139

memcpy(collection, parser->device->collection,

140

sizeof(struct hid_collection) *

140

sizeof(struct hid_collection) *

141

parser->device->collection_size);

141

parser->device->collection_size);

142

memset(collection + parser->device->collection_size, 0,

142

memset(collection + parser->device->collection_size, 0,

143

sizeof(struct hid_collection) *

143

sizeof(struct hid_collection) *

144

parser->device->collection_size);

144

parser->device->collection_size);

145

kfree(parser->device->collection);

145

kfree(parser->device->collection);

146

parser->device->collection = collection;

146

parser->device->collection = collection;

147

parser->device->collection_size *= 2;

147

parser->device->collection_size *= 2;

148

}

148

}

149

150

parser->collection_stack[parser->collection_stack_ptr++] =

150

parser->collection_stack[parser->collection_stack_ptr++] =

151

parser->device->maxcollection;

151

parser->device->maxcollection;

152

153

collection = parser->device->collection +

153

collection = parser->device->collection +

154

parser->device->maxcollection++;

154

parser->device->maxcollection++;

155

collection->type = type;

155

collection->type = type;

156

collection->usage = usage;

156

collection->usage = usage;

157

collection->level = parser->collection_stack_ptr - 1;

157

collection->level = parser->collection_stack_ptr - 1;

158

159

if (type == HID_COLLECTION_APPLICATION)

159

if (type == HID_COLLECTION_APPLICATION)

160

parser->device->maxapplication++;

160

parser->device->maxapplication++;

161

162

return 0;

162

return 0;

163

}

163

}

164

165

/*

165

/*

166

* Close a collection.

166

* Close a collection.

167

*/

167

*/

168

169

static int close_collection(struct hid_parser *parser)

169

static int close_collection(struct hid_parser *parser)

170

{

170

{

171

if (!parser->collection_stack_ptr) {

171

if (!parser->collection_stack_ptr) {

172

hid_err(parser->device, "collection stack underflow\n");

172

hid_err(parser->device, "collection stack underflow\n");

173

return -1;

173

return -1;

174

}

174

}

175

parser->collection_stack_ptr--;

175

parser->collection_stack_ptr--;

176

return 0;

176

return 0;

177

}

177

}

178

179

/*

179

/*

180

* Climb up the stack, search for the specified collection type

180

* Climb up the stack, search for the specified collection type

181

* and return the usage.

181

* and return the usage.

182

*/

182

*/

183

184

static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)

184

static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)

185

{

185

{

186

struct hid_collection *collection = parser->device->collection;

186

struct hid_collection *collection = parser->device->collection;

187

int n;

187

int n;

188

189

for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {

189

for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {

190

unsigned index = parser->collection_stack[n];

190

unsigned index = parser->collection_stack[n];

191

if (collection[index].type == type)

191

if (collection[index].type == type)

192

return collection[index].usage;

192

return collection[index].usage;

193

}

193

}

194

return 0; /* we know nothing about this usage type */

194

return 0; /* we know nothing about this usage type */

195

}

195

}

196

197

/*

197

/*

198

* Add a usage to the temporary parser table.

198

* Add a usage to the temporary parser table.

199

*/

199

*/

200

201

static int hid_add_usage(struct hid_parser *parser, unsigned usage)

201

static int hid_add_usage(struct hid_parser *parser, unsigned usage)

202

{

202

{

203

if (parser->local.usage_index >= HID_MAX_USAGES) {

203

if (parser->local.usage_index >= HID_MAX_USAGES) {

204

hid_err(parser->device, "usage index exceeded\n");

204

hid_err(parser->device, "usage index exceeded\n");

205

return -1;

205

return -1;

206

}

206

}

207

parser->local.usage[parser->local.usage_index] = usage;

207

parser->local.usage[parser->local.usage_index] = usage;

208

parser->local.collection_index[parser->local.usage_index] =

208

parser->local.collection_index[parser->local.usage_index] =

209

parser->collection_stack_ptr ?

209

parser->collection_stack_ptr ?

210

parser->collection_stack[parser->collection_stack_ptr - 1] : 0;

210

parser->collection_stack[parser->collection_stack_ptr - 1] : 0;

211

parser->local.usage_index++;

211

parser->local.usage_index++;

212

return 0;

212

return 0;

213

}

213

}

214

215

/*

215

/*

216

* Register a new field for this report.

216

* Register a new field for this report.

217

*/

217

*/

218

219

static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)

219

static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)

220

{

220

{

221

struct hid_report *report;

221

struct hid_report *report;

222

struct hid_field *field;

222

struct hid_field *field;

223

int usages;

223

int usages;

224

unsigned offset;

224

unsigned offset;

225

int i;

225

int i;

226

227

report = hid_register_report(parser->device, report_type, parser->global.report_id);

227

report = hid_register_report(parser->device, report_type, parser->global.report_id);

228

if (!report) {

228

if (!report) {

229

hid_err(parser->device, "hid_register_report failed\n");

229

hid_err(parser->device, "hid_register_report failed\n");

230

return -1;

230

return -1;

231

}

231

}

232

233

if (parser->global.logical_maximum < parser->global.logical_minimum) {

233

if (parser->global.logical_maximum < parser->global.logical_minimum) {

234

hid_err(parser->device, "logical range invalid %d %d\n",

234

hid_err(parser->device, "logical range invalid %d %d\n",

235

parser->global.logical_minimum, parser->global.logical_maximum);

235

parser->global.logical_minimum, parser->global.logical_maximum);

236

return -1;

236

return -1;

237

}

237

}

238

239

offset = report->size;

239

offset = report->size;

240

report->size += parser->global.report_size * parser->global.report_count;

240

report->size += parser->global.report_size * parser->global.report_count;

241

242

if (!parser->local.usage_index) /* Ignore padding fields */

242

if (!parser->local.usage_index) /* Ignore padding fields */

243

return 0;

243

return 0;

244

245

usages = max_t(int, parser->local.usage_index, parser->global.report_count);

245

usages = max_t(int, parser->local.usage_index, parser->global.report_count);

246

247

field = hid_register_field(report, usages, parser->global.report_count);

247

field = hid_register_field(report, usages, parser->global.report_count);

248

if (!field)

248

if (!field)

249

return 0;

249

return 0;

250

251

field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);

251

field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);

252

field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);

252

field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);

253

field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);

253

field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);

254

255

for (i = 0; i < usages; i++) {

255

for (i = 0; i < usages; i++) {

256

int j = i;

256

int j = i;

257

/* Duplicate the last usage we parsed if we have excess values */

257

/* Duplicate the last usage we parsed if we have excess values */

258

if (i >= parser->local.usage_index)

258

if (i >= parser->local.usage_index)

259

j = parser->local.usage_index - 1;

259

j = parser->local.usage_index - 1;

260

field->usage[i].hid = parser->local.usage[j];

260

field->usage[i].hid = parser->local.usage[j];

261

field->usage[i].collection_index =

261

field->usage[i].collection_index =

262

parser->local.collection_index[j];

262

parser->local.collection_index[j];

263

}

263

}

264

265

field->maxusage = usages;

265

field->maxusage = usages;

266

field->flags = flags;

266

field->flags = flags;

267

field->report_offset = offset;

267

field->report_offset = offset;

268

field->report_type = report_type;

268

field->report_type = report_type;

269

field->report_size = parser->global.report_size;

269

field->report_size = parser->global.report_size;

270

field->report_count = parser->global.report_count;

270

field->report_count = parser->global.report_count;

271

field->logical_minimum = parser->global.logical_minimum;

271

field->logical_minimum = parser->global.logical_minimum;

272

field->logical_maximum = parser->global.logical_maximum;

272

field->logical_maximum = parser->global.logical_maximum;

273

field->physical_minimum = parser->global.physical_minimum;

273

field->physical_minimum = parser->global.physical_minimum;

274

field->physical_maximum = parser->global.physical_maximum;

274

field->physical_maximum = parser->global.physical_maximum;

275

field->unit_exponent = parser->global.unit_exponent;

275

field->unit_exponent = parser->global.unit_exponent;

276

field->unit = parser->global.unit;

276

field->unit = parser->global.unit;

277

278

return 0;

278

return 0;

279

}

279

}

280

281

/*

281

/*

282

* Read data value from item.

282

* Read data value from item.

283

*/

283

*/

284

285

static u32 item_udata(struct hid_item *item)

285

static u32 item_udata(struct hid_item *item)

286

{

286

{

287

switch (item->size) {

287

switch (item->size) {

288

case 1: return item->data.u8;

288

case 1: return item->data.u8;

289

case 2: return item->data.u16;

289

case 2: return item->data.u16;

290

case 4: return item->data.u32;

290

case 4: return item->data.u32;

291

}

291

}

292

return 0;

292

return 0;

293

}

293

}

294

295

static s32 item_sdata(struct hid_item *item)

295

static s32 item_sdata(struct hid_item *item)

296

{

296

{

297

switch (item->size) {

297

switch (item->size) {

298

case 1: return item->data.s8;

298

case 1: return item->data.s8;

299

case 2: return item->data.s16;

299

case 2: return item->data.s16;

300

case 4: return item->data.s32;

300

case 4: return item->data.s32;

301

}

301

}

302

return 0;

302

return 0;

303

}

303

}

304

305

/*

305

/*

306

* Process a global item.

306

* Process a global item.

307

*/

307

*/

308

309

static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)

309

static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)

310

{

310

{

311

switch (item->tag) {

311

switch (item->tag) {

312

case HID_GLOBAL_ITEM_TAG_PUSH:

312

case HID_GLOBAL_ITEM_TAG_PUSH:

313

314

if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {

314

if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {

315

hid_err(parser->device, "global environment stack overflow\n");

315

hid_err(parser->device, "global environment stack overflow\n");

316

return -1;

316

return -1;

317

}

317

}

318

319

memcpy(parser->global_stack + parser->global_stack_ptr++,

319

memcpy(parser->global_stack + parser->global_stack_ptr++,

320

&parser->global, sizeof(struct hid_global));

320

&parser->global, sizeof(struct hid_global));

321

return 0;

321

return 0;

322

323

case HID_GLOBAL_ITEM_TAG_POP:

323

case HID_GLOBAL_ITEM_TAG_POP:

324

325

if (!parser->global_stack_ptr) {

325

if (!parser->global_stack_ptr) {

326

hid_err(parser->device, "global environment stack underflow\n");

326

hid_err(parser->device, "global environment stack underflow\n");

327

return -1;

327

return -1;

328

}

328

}

329

330

memcpy(&parser->global, parser->global_stack +

330

memcpy(&parser->global, parser->global_stack +

331

--parser->global_stack_ptr, sizeof(struct hid_global));

331

--parser->global_stack_ptr, sizeof(struct hid_global));

332

return 0;

332

return 0;

333

334

case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:

334

case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:

335

parser->global.usage_page = item_udata(item);

335

parser->global.usage_page = item_udata(item);

336

return 0;

336

return 0;

337

338

case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:

338

case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:

339

parser->global.logical_minimum = item_sdata(item);

339

parser->global.logical_minimum = item_sdata(item);

340

return 0;

340

return 0;

341

342

case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:

342

case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:

343

if (parser->global.logical_minimum < 0)

343

if (parser->global.logical_minimum < 0)

344

parser->global.logical_maximum = item_sdata(item);

344

parser->global.logical_maximum = item_sdata(item);

345

else

345

else

346

parser->global.logical_maximum = item_udata(item);

346

parser->global.logical_maximum = item_udata(item);

347

return 0;

347

return 0;

348

349

case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:

349

case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:

350

parser->global.physical_minimum = item_sdata(item);

350

parser->global.physical_minimum = item_sdata(item);

351

return 0;

351

return 0;

352

353

case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:

353

case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:

354

if (parser->global.physical_minimum < 0)

354

if (parser->global.physical_minimum < 0)

355

parser->global.physical_maximum = item_sdata(item);

355

parser->global.physical_maximum = item_sdata(item);

356

else

356

else

357

parser->global.physical_maximum = item_udata(item);

357

parser->global.physical_maximum = item_udata(item);

358

return 0;

358

return 0;

359

360

case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:

360

case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:

361

parser->global.unit_exponent = item_sdata(item);

361

parser->global.unit_exponent = item_sdata(item);

362

return 0;

362

return 0;

363

364

case HID_GLOBAL_ITEM_TAG_UNIT:

364

case HID_GLOBAL_ITEM_TAG_UNIT:

365

parser->global.unit = item_udata(item);

365

parser->global.unit = item_udata(item);

366

return 0;

366

return 0;

367

368

case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:

368

case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:

369

parser->global.report_size = item_udata(item);

369

parser->global.report_size = item_udata(item);

370

if (parser->global.report_size > 96) {

370

if (parser->global.report_size > 96) {

371

hid_err(parser->device, "invalid report_size %d\n",

371

hid_err(parser->device, "invalid report_size %d\n",

372

parser->global.report_size);

372

parser->global.report_size);

373

return -1;

373

return -1;

374

}

374

}

375

return 0;

375

return 0;

376

377

case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:

377

case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:

378

parser->global.report_count = item_udata(item);

378

parser->global.report_count = item_udata(item);

379

if (parser->global.report_count > HID_MAX_USAGES) {

379

if (parser->global.report_count > HID_MAX_USAGES) {

380

hid_err(parser->device, "invalid report_count %d\n",

380

hid_err(parser->device, "invalid report_count %d\n",

381

parser->global.report_count);

381

parser->global.report_count);

382

return -1;

382

return -1;

383

}

383

}

384

return 0;

384

return 0;

385

386

case HID_GLOBAL_ITEM_TAG_REPORT_ID:

386

case HID_GLOBAL_ITEM_TAG_REPORT_ID:

387

parser->global.report_id = item_udata(item);

387

parser->global.report_id = item_udata(item);

388

if (parser->global.report_id == 0) {

388

if (parser->global.report_id == 0) {

389

hid_err(parser->device, "report_id 0 is invalid\n");

389

hid_err(parser->device, "report_id 0 is invalid\n");

390

return -1;

390

return -1;

391

}

391

}

392

return 0;

392

return 0;

393

394

default:

394

default:

395

hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);

395

hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);

396

return -1;

396

return -1;

397

}

397

}

398

}

398

}

399

400

/*

400

/*

401

* Process a local item.

401

* Process a local item.

402

*/

402

*/

403

404

static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)

404

static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)

405

{

405

{

406

__u32 data;

406

__u32 data;

407

unsigned n;

407

unsigned n;

408

409

data = item_udata(item);

409

data = item_udata(item);

410

411

switch (item->tag) {

411

switch (item->tag) {

412

case HID_LOCAL_ITEM_TAG_DELIMITER:

412

case HID_LOCAL_ITEM_TAG_DELIMITER:

413

414

if (data) {

414

if (data) {

415

/*

415

/*

416

* We treat items before the first delimiter

416

* We treat items before the first delimiter

417

* as global to all usage sets (branch 0).

417

* as global to all usage sets (branch 0).

418

* In the moment we process only these global

418

* In the moment we process only these global

419

* items and the first delimiter set.

419

* items and the first delimiter set.

420

*/

420

*/

421

if (parser->local.delimiter_depth != 0) {

421

if (parser->local.delimiter_depth != 0) {

422

hid_err(parser->device, "nested delimiters\n");

422

hid_err(parser->device, "nested delimiters\n");

423

return -1;

423

return -1;

424

}

424

}

425

parser->local.delimiter_depth++;

425

parser->local.delimiter_depth++;

426

parser->local.delimiter_branch++;

426

parser->local.delimiter_branch++;

427

} else {

427

} else {

428

if (parser->local.delimiter_depth < 1) {

428

if (parser->local.delimiter_depth < 1) {

429

hid_err(parser->device, "bogus close delimiter\n");

429

hid_err(parser->device, "bogus close delimiter\n");

430

return -1;

430

return -1;

431

}

431

}

432

parser->local.delimiter_depth--;

432

parser->local.delimiter_depth--;

433

}

433

}

434

return 1;

434

return 1;

435

436

case HID_LOCAL_ITEM_TAG_USAGE:

436

case HID_LOCAL_ITEM_TAG_USAGE:

437

438

if (parser->local.delimiter_branch > 1) {

438

if (parser->local.delimiter_branch > 1) {

439

dbg_hid("alternative usage ignored\n");

439

dbg_hid("alternative usage ignored\n");

440

return 0;

440

return 0;

441

}

441

}

442

443

if (item->size <= 2)

443

if (item->size <= 2)

444

data = (parser->global.usage_page << 16) + data;

444

data = (parser->global.usage_page << 16) + data;

445

446

return hid_add_usage(parser, data);

446

return hid_add_usage(parser, data);

447

448

case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:

448

case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:

449

450

if (parser->local.delimiter_branch > 1) {

450

if (parser->local.delimiter_branch > 1) {

451

dbg_hid("alternative usage ignored\n");

451

dbg_hid("alternative usage ignored\n");

452

return 0;

452

return 0;

453

}

453

}

454

455

if (item->size <= 2)

455

if (item->size <= 2)

456

data = (parser->global.usage_page << 16) + data;

456

data = (parser->global.usage_page << 16) + data;

457

458

parser->local.usage_minimum = data;

458

parser->local.usage_minimum = data;

459

return 0;

459

return 0;

460

461

case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:

461

case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:

462

463

if (parser->local.delimiter_branch > 1) {

463

if (parser->local.delimiter_branch > 1) {

464

dbg_hid("alternative usage ignored\n");

464

dbg_hid("alternative usage ignored\n");

465

return 0;

465

return 0;

466

}

466

}

467

468

if (item->size <= 2)

468

if (item->size <= 2)

469

data = (parser->global.usage_page << 16) + data;

469

data = (parser->global.usage_page << 16) + data;

470

471

for (n = parser->local.usage_minimum; n <= data; n++)

471

for (n = parser->local.usage_minimum; n <= data; n++)

472

if (hid_add_usage(parser, n)) {

472

if (hid_add_usage(parser, n)) {

473

dbg_hid("hid_add_usage failed\n");

473

dbg_hid("hid_add_usage failed\n");

474

return -1;

474

return -1;

475

}

475

}

476

return 0;

476

return 0;

477

478

default:

478

default:

479

480

dbg_hid("unknown local item tag 0x%x\n", item->tag);

480

dbg_hid("unknown local item tag 0x%x\n", item->tag);

481

return 0;

481

return 0;

482

}

482

}

483

return 0;

483

return 0;

484

}

484

}

485

486

/*

486

/*

487

* Process a main item.

487

* Process a main item.

488

*/

488

*/

489

490

static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)

490

static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)

491

{

491

{

492

__u32 data;

492

__u32 data;

493

int ret;

493

int ret;

494

495

data = item_udata(item);

495

data = item_udata(item);

496

497

switch (item->tag) {

497

switch (item->tag) {

498

case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:

498

case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:

499

ret = open_collection(parser, data & 0xff);

499

ret = open_collection(parser, data & 0xff);

500

break;

500

break;

501

case HID_MAIN_ITEM_TAG_END_COLLECTION:

501

case HID_MAIN_ITEM_TAG_END_COLLECTION:

502

ret = close_collection(parser);

502

ret = close_collection(parser);

503

break;

503

break;

504

case HID_MAIN_ITEM_TAG_INPUT:

504

case HID_MAIN_ITEM_TAG_INPUT:

505

ret = hid_add_field(parser, HID_INPUT_REPORT, data);

505

ret = hid_add_field(parser, HID_INPUT_REPORT, data);

506

break;

506

break;

507

case HID_MAIN_ITEM_TAG_OUTPUT:

507

case HID_MAIN_ITEM_TAG_OUTPUT:

508

ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);

508

ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);

509

break;

509

break;

510

case HID_MAIN_ITEM_TAG_FEATURE:

510

case HID_MAIN_ITEM_TAG_FEATURE:

511

ret = hid_add_field(parser, HID_FEATURE_REPORT, data);

511

ret = hid_add_field(parser, HID_FEATURE_REPORT, data);

512

break;

512

break;

513

default:

513

default:

514

hid_err(parser->device, "unknown main item tag 0x%x\n", item->tag);

514

hid_err(parser->device, "unknown main item tag 0x%x\n", item->tag);

515

ret = 0;

515

ret = 0;

516

}

516

}

517

518

memset(&parser->local, 0, sizeof(parser->local)); /* Reset the local parser environment */

518

memset(&parser->local, 0, sizeof(parser->local)); /* Reset the local parser environment */

519

520

return ret;

520

return ret;

521

}

521

}

522

523

/*

523

/*

524

* Process a reserved item.

524

* Process a reserved item.

525

*/

525

*/

526

527

static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)

527

static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)

528

{

528

{

529

dbg_hid("reserved item type, tag 0x%x\n", item->tag);

529

dbg_hid("reserved item type, tag 0x%x\n", item->tag);

530

return 0;

530

return 0;

531

}

531

}

532

533

/*

533

/*

534

* Free a report and all registered fields. The field->usage and

534

* Free a report and all registered fields. The field->usage and

535

* field->value table's are allocated behind the field, so we need

535

* field->value table's are allocated behind the field, so we need

536

* only to free(field) itself.

536

* only to free(field) itself.

537

*/

537

*/

538

539

static void hid_free_report(struct hid_report *report)

539

static void hid_free_report(struct hid_report *report)

540

{

540

{

541

unsigned n;

541

unsigned n;

542

543

for (n = 0; n < report->maxfield; n++)

543

for (n = 0; n < report->maxfield; n++)

544

kfree(report->field[n]);

544

kfree(report->field[n]);

545

kfree(report);

545

kfree(report);

546

}

546

}

547

548

/*

548

/*

549

* Free a device structure, all reports, and all fields.

549

* Free a device structure, all reports, and all fields.

550

*/

550

*/

551

552

static void hid_device_release(struct device *dev)

552

static void hid_device_release(struct device *dev)

553

{

553

{

554

struct hid_device *device = container_of(dev, struct hid_device, dev);

554

struct hid_device *device = container_of(dev, struct hid_device, dev);

555

unsigned i, j;

555

unsigned i, j;

556

557

for (i = 0; i < HID_REPORT_TYPES; i++) {

557

for (i = 0; i < HID_REPORT_TYPES; i++) {

558

struct hid_report_enum *report_enum = device->report_enum + i;

558

struct hid_report_enum *report_enum = device->report_enum + i;

559

560

for (j = 0; j < 256; j++) {

560

for (j = 0; j < 256; j++) {

561

struct hid_report *report = report_enum->report_id_hash[j];

561

struct hid_report *report = report_enum->report_id_hash[j];

562

if (report)

562

if (report)

563

hid_free_report(report);

563

hid_free_report(report);

564

}

564

}

565

}

565

}

566

567

kfree(device->rdesc);

567

kfree(device->rdesc);

568

kfree(device->collection);

568

kfree(device->collection);

569

kfree(device);

569

kfree(device);

570

}

570

}

571

572

/*

572

/*

573

* Fetch a report description item from the data stream. We support long

573

* Fetch a report description item from the data stream. We support long

574

* items, though they are not used yet.

574

* items, though they are not used yet.

575

*/

575

*/

576

577

static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)

577

static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)

578

{

578

{

579

u8 b;

579

u8 b;

580

581

if ((end - start) <= 0)

581

if ((end - start) <= 0)

582

return NULL;

582

return NULL;

583

584

b = *start++;

584

b = *start++;

585

586

item->type = (b >> 2) & 3;

586

item->type = (b >> 2) & 3;

587

item->tag = (b >> 4) & 15;

587

item->tag = (b >> 4) & 15;

588

589

if (item->tag == HID_ITEM_TAG_LONG) {

589

if (item->tag == HID_ITEM_TAG_LONG) {

590

591

item->format = HID_ITEM_FORMAT_LONG;

591

item->format = HID_ITEM_FORMAT_LONG;

592

593

if ((end - start) < 2)

593

if ((end - start) < 2)

594

return NULL;

594

return NULL;

595

596

item->size = *start++;

596

item->size = *start++;

597

item->tag = *start++;

597

item->tag = *start++;

598

599

if ((end - start) < item->size)

599

if ((end - start) < item->size)

600

return NULL;

600

return NULL;

601

602

item->data.longdata = start;

602

item->data.longdata = start;

603

start += item->size;

603

start += item->size;

604

return start;

604

return start;

605

}

605

}

606

607

item->format = HID_ITEM_FORMAT_SHORT;

607

item->format = HID_ITEM_FORMAT_SHORT;

608

item->size = b & 3;

608

item->size = b & 3;

609

610

switch (item->size) {

610

switch (item->size) {

611

case 0:

611

case 0:

612

return start;

612

return start;

613

614

case 1:

614

case 1:

615

if ((end - start) < 1)

615

if ((end - start) < 1)

616

return NULL;

616

return NULL;

617

item->data.u8 = *start++;

617

item->data.u8 = *start++;

618

return start;

618

return start;

619

620

case 2:

620

case 2:

621

if ((end - start) < 2)

621

if ((end - start) < 2)

622

return NULL;

622

return NULL;

623

item->data.u16 = get_unaligned_le16(start);

623

item->data.u16 = get_unaligned_le16(start);

624

start = (__u8 *)((__le16 *)start + 1);

624

start = (__u8 *)((__le16 *)start + 1);

625

return start;

625

return start;

626

627

case 3:

627

case 3:

628

item->size++;

628

item->size++;

629

if ((end - start) < 4)

629

if ((end - start) < 4)

630

return NULL;

630

return NULL;

631

item->data.u32 = get_unaligned_le32(start);

631

item->data.u32 = get_unaligned_le32(start);

632

start = (__u8 *)((__le32 *)start + 1);

632

start = (__u8 *)((__le32 *)start + 1);

633

return start;

633

return start;

634

}

634

}

635

636

return NULL;

636

return NULL;

637

}

637

}

638

639

/**

639

/**

640

* hid_parse_report - parse device report

640

* hid_parse_report - parse device report

641

*

641

*

642

* @device: hid device

642

* @device: hid device

643

* @start: report start

643

* @start: report start

644

* @size: report size

644

* @size: report size

645

*

645

*

646

* Parse a report description into a hid_device structure. Reports are

646

* Parse a report description into a hid_device structure. Reports are

647

* enumerated, fields are attached to these reports.

647

* enumerated, fields are attached to these reports.

648

* 0 returned on success, otherwise nonzero error value.

648

* 0 returned on success, otherwise nonzero error value.

649

*/

649

*/

650

int hid_parse_report(struct hid_device *device, __u8 *start,

650

int hid_parse_report(struct hid_device *device, __u8 *start,

651

unsigned size)

651

unsigned size)

652

{

652

{

653

struct hid_parser *parser;

653

struct hid_parser *parser;

654

struct hid_item item;

654

struct hid_item item;

655

__u8 *end;

655

__u8 *end;

656

int ret;

656

int ret;

657

static int (*dispatch_type[])(struct hid_parser *parser,

657

static int (*dispatch_type[])(struct hid_parser *parser,

658

struct hid_item *item) = {

658

struct hid_item *item) = {

659

hid_parser_main,

659

hid_parser_main,

660

hid_parser_global,

660

hid_parser_global,

661

hid_parser_local,

661

hid_parser_local,

662

hid_parser_reserved

662

hid_parser_reserved

663

};

663

};

664

665

if (device->driver->report_fixup)

665

if (device->driver->report_fixup)

666

start = device->driver->report_fixup(device, start, &size);

666

start = device->driver->report_fixup(device, start, &size);

667

668

device->rdesc = kmemdup(start, size, GFP_KERNEL);

668

device->rdesc = kmemdup(start, size, GFP_KERNEL);

669

if (device->rdesc == NULL)

669

if (device->rdesc == NULL)

670

return -ENOMEM;

670

return -ENOMEM;

671

device->rsize = size;

671

device->rsize = size;

672

673

parser = vzalloc(sizeof(struct hid_parser));

673

parser = vzalloc(sizeof(struct hid_parser));

674

if (!parser) {

674

if (!parser) {

675

ret = -ENOMEM;

675

ret = -ENOMEM;

676

goto err;

676

goto err;

677

}

677

}

678

679

parser->device = device;

679

parser->device = device;

680

681

end = start + size;

681

end = start + size;

682

ret = -EINVAL;

682

ret = -EINVAL;

683

while ((start = fetch_item(start, end, &item)) != NULL) {

683

while ((start = fetch_item(start, end, &item)) != NULL) {

684

685

if (item.format != HID_ITEM_FORMAT_SHORT) {

685

if (item.format != HID_ITEM_FORMAT_SHORT) {

686

hid_err(device, "unexpected long global item\n");

686

hid_err(device, "unexpected long global item\n");

687

goto err;

687

goto err;

688

}

688

}

689

690

if (dispatch_type[item.type](parser, &item)) {

690

if (dispatch_type[item.type](parser, &item)) {

691

hid_err(device, "item %u %u %u %u parsing failed\n",

691

hid_err(device, "item %u %u %u %u parsing failed\n",

692

item.format, (unsigned)item.size,

692

item.format, (unsigned)item.size,

693

(unsigned)item.type, (unsigned)item.tag);

693

(unsigned)item.type, (unsigned)item.tag);

694

goto err;

694

goto err;

695

}

695

}

696

697

if (start == end) {

697

if (start == end) {

698

if (parser->collection_stack_ptr) {

698

if (parser->collection_stack_ptr) {

699

hid_err(device, "unbalanced collection at end of report description\n");

699

hid_err(device, "unbalanced collection at end of report description\n");

700

goto err;

700

goto err;

701

}

701

}

702

if (parser->local.delimiter_depth) {

702

if (parser->local.delimiter_depth) {

703

hid_err(device, "unbalanced delimiter at end of report description\n");

703

hid_err(device, "unbalanced delimiter at end of report description\n");

704

goto err;

704

goto err;

705

}

705

}

706

vfree(parser);

706

vfree(parser);

707

return 0;

707

return 0;

708

}

708

}

709

}

709

}

710

711

hid_err(device, "item fetching failed at offset %d\n", (int)(end - start));

711

hid_err(device, "item fetching failed at offset %d\n", (int)(end - start));

712

err:

712

err:

713

vfree(parser);

713

vfree(parser);

714

return ret;

714

return ret;

715

}

715

}

716

EXPORT_SYMBOL_GPL(hid_parse_report);

716

EXPORT_SYMBOL_GPL(hid_parse_report);

717

718

/*

718

/*

719

* Convert a signed n-bit integer to signed 32-bit integer. Common

719

* Convert a signed n-bit integer to signed 32-bit integer. Common

720

* cases are done through the compiler, the screwed things has to be

720

* cases are done through the compiler, the screwed things has to be

721

* done by hand.

721

* done by hand.

722

*/

722

*/

723

724

static s32 snto32(__u32 value, unsigned n)

724

static s32 snto32(__u32 value, unsigned n)

725

{

725

{

726

switch (n) {

726

switch (n) {

727

case 8: return ((__s8)value);

727

case 8: return ((__s8)value);

728

case 16: return ((__s16)value);

728

case 16: return ((__s16)value);

729

case 32: return ((__s32)value);

729

case 32: return ((__s32)value);

730

}

730

}

731

return value & (1 << (n - 1)) ? value | (-1 << n) : value;

731

return value & (1 << (n - 1)) ? value | (-1 << n) : value;

732

}

732

}

733

734

/*

734

/*

735

* Convert a signed 32-bit integer to a signed n-bit integer.

735

* Convert a signed 32-bit integer to a signed n-bit integer.

736

*/

736

*/

737

738

static u32 s32ton(__s32 value, unsigned n)

738

static u32 s32ton(__s32 value, unsigned n)

739

{

739

{

740

s32 a = value >> (n - 1);

740

s32 a = value >> (n - 1);

741

if (a && a != -1)

741

if (a && a != -1)

742

return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;

742

return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;

743

return value & ((1 << n) - 1);

743

return value & ((1 << n) - 1);

744

}

744

}

745

746

/*

746

/*

747

* Extract/implement a data field from/to a little endian report (bit array).

747

* Extract/implement a data field from/to a little endian report (bit array).

748

*

748

*

749

* Code sort-of follows HID spec:

749

* Code sort-of follows HID spec:

750

* http://www.usb.org/developers/devclass_docs/HID1_11.pdf

750

* http://www.usb.org/developers/devclass_docs/HID1_11.pdf

751

*

751

*

752

* While the USB HID spec allows unlimited length bit fields in "report

752

* While the USB HID spec allows unlimited length bit fields in "report

753

* descriptors", most devices never use more than 16 bits.

753

* descriptors", most devices never use more than 16 bits.

754

* One model of UPS is claimed to report "LINEV" as a 32-bit field.

754

* One model of UPS is claimed to report "LINEV" as a 32-bit field.

755

* Search linux-kernel and linux-usb-devel archives for "hid-core extract".

755

* Search linux-kernel and linux-usb-devel archives for "hid-core extract".

756

*/

756

*/

757

758

static __u32 extract(const struct hid_device *hid, __u8 *report,

758

static __u32 extract(const struct hid_device *hid, __u8 *report,

759

unsigned offset, unsigned n)

759

unsigned offset, unsigned n)

760

{

760

{

761

u64 x;

761

u64 x;

762

763

if (n > 32)

763

if (n > 32)

764

hid_warn(hid, "extract() called with n (%d) > 32! (%s)\n",

764

hid_warn(hid, "extract() called with n (%d) > 32! (%s)\n",

765

n, current->comm);

765

n, current->comm);

766

767

report += offset >> 3; /* adjust byte index */

767

report += offset >> 3; /* adjust byte index */

768

offset &= 7; /* now only need bit offset into one byte */

768

offset &= 7; /* now only need bit offset into one byte */

769

x = get_unaligned_le64(report);

769

x = get_unaligned_le64(report);

770

x = (x >> offset) & ((1ULL << n) - 1); /* extract bit field */

770

x = (x >> offset) & ((1ULL << n) - 1); /* extract bit field */

771

return (u32) x;

771

return (u32) x;

772

}

772

}

773

774

/*

774

/*

775

* "implement" : set bits in a little endian bit stream.

775

* "implement" : set bits in a little endian bit stream.

776

* Same concepts as "extract" (see comments above).

776

* Same concepts as "extract" (see comments above).

777

* The data mangled in the bit stream remains in little endian

777

* The data mangled in the bit stream remains in little endian

778

* order the whole time. It make more sense to talk about

778

* order the whole time. It make more sense to talk about

779

* endianness of register values by considering a register

779

* endianness of register values by considering a register

780

* a "cached" copy of the little endiad bit stream.

780

* a "cached" copy of the little endiad bit stream.

781

*/

781

*/

782

static void implement(const struct hid_device *hid, __u8 *report,

782

static void implement(const struct hid_device *hid, __u8 *report,

783

unsigned offset, unsigned n, __u32 value)

783

unsigned offset, unsigned n, __u32 value)

784

{

784

{

785

u64 x;

785

u64 x;

786

u64 m = (1ULL << n) - 1;

786

u64 m = (1ULL << n) - 1;

787

788

if (n > 32)

788

if (n > 32)

789

hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",

789

hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",

790

__func__, n, current->comm);

790

__func__, n, current->comm);

791

792

if (value > m)

792

if (value > m)

793

hid_warn(hid, "%s() called with too large value %d! (%s)\n",

793

hid_warn(hid, "%s() called with too large value %d! (%s)\n",

794

__func__, value, current->comm);

794

__func__, value, current->comm);

795

WARN_ON(value > m);

795

WARN_ON(value > m);

796

value &= m;

796

value &= m;

797

798

report += offset >> 3;

798

report += offset >> 3;

799

offset &= 7;

799

offset &= 7;

800

801

x = get_unaligned_le64(report);

801

x = get_unaligned_le64(report);

802

x &= ~(m << offset);

802

x &= ~(m << offset);

803

x |= ((u64)value) << offset;

803

x |= ((u64)value) << offset;

804

put_unaligned_le64(x, report);

804

put_unaligned_le64(x, report);

805

}

805

}

806

807

/*

807

/*

808

* Search an array for a value.

808

* Search an array for a value.

809

*/

809

*/

810

811

static int search(__s32 *array, __s32 value, unsigned n)

811

static int search(__s32 *array, __s32 value, unsigned n)

812

{

812

{

813

while (n--) {

813

while (n--) {

814

if (*array++ == value)

814

if (*array++ == value)

815

return 0;

815

return 0;

816

}

816

}

817

return -1;

817

return -1;

818

}

818

}

819

820

/**

820

/**

821

* hid_match_report - check if driver's raw_event should be called

821

* hid_match_report - check if driver's raw_event should be called

822

*

822

*

823

* @hid: hid device

823

* @hid: hid device

824

* @report_type: type to match against

824

* @report_type: type to match against

825

*

825

*

826

* compare hid->driver->report_table->report_type to report->type

826

* compare hid->driver->report_table->report_type to report->type

827

*/

827

*/

828

static int hid_match_report(struct hid_device *hid, struct hid_report *report)

828

static int hid_match_report(struct hid_device *hid, struct hid_report *report)

829

{

829

{

830

const struct hid_report_id *id = hid->driver->report_table;

830

const struct hid_report_id *id = hid->driver->report_table;

831

832

if (!id) /* NULL means all */

832

if (!id) /* NULL means all */

833

return 1;

833

return 1;

834

835

for (; id->report_type != HID_TERMINATOR; id++)

835

for (; id->report_type != HID_TERMINATOR; id++)

836

if (id->report_type == HID_ANY_ID ||

836

if (id->report_type == HID_ANY_ID ||

837

id->report_type == report->type)

837

id->report_type == report->type)

838

return 1;

838

return 1;

839

return 0;

839

return 0;

840

}

840

}

841

842

/**

842

/**

843

* hid_match_usage - check if driver's event should be called

843

* hid_match_usage - check if driver's event should be called

844

*

844

*

845

* @hid: hid device

845

* @hid: hid device

846

* @usage: usage to match against

846

* @usage: usage to match against

847

*

847

*

848

* compare hid->driver->usage_table->usage_{type,code} to

848

* compare hid->driver->usage_table->usage_{type,code} to

849

* usage->usage_{type,code}

849

* usage->usage_{type,code}

850

*/

850

*/

851

static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)

851

static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)

852

{

852

{

853

const struct hid_usage_id *id = hid->driver->usage_table;

853

const struct hid_usage_id *id = hid->driver->usage_table;

854

855

if (!id) /* NULL means all */

855

if (!id) /* NULL means all */

856

return 1;

856

return 1;

857

858

for (; id->usage_type != HID_ANY_ID - 1; id++)

858

for (; id->usage_type != HID_ANY_ID - 1; id++)

859

if ((id->usage_hid == HID_ANY_ID ||

859

if ((id->usage_hid == HID_ANY_ID ||

860

id->usage_hid == usage->hid) &&

860

id->usage_hid == usage->hid) &&

861

(id->usage_type == HID_ANY_ID ||

861

(id->usage_type == HID_ANY_ID ||

862

id->usage_type == usage->type) &&

862

id->usage_type == usage->type) &&

863

(id->usage_code == HID_ANY_ID ||

863

(id->usage_code == HID_ANY_ID ||

864

id->usage_code == usage->code))

864

id->usage_code == usage->code))

865

return 1;

865

return 1;

866

return 0;

866

return 0;

867

}

867

}

868

869

static void hid_process_event(struct hid_device *hid, struct hid_field *field,

869

static void hid_process_event(struct hid_device *hid, struct hid_field *field,

870

struct hid_usage *usage, __s32 value, int interrupt)

870

struct hid_usage *usage, __s32 value, int interrupt)

871

{

871

{

872

struct hid_driver *hdrv = hid->driver;

872

struct hid_driver *hdrv = hid->driver;

873

int ret;

873

int ret;

874

875

hid_dump_input(hid, usage, value);

875

hid_dump_input(hid, usage, value);

876

877

if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {

877

if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {

878

ret = hdrv->event(hid, field, usage, value);

878

ret = hdrv->event(hid, field, usage, value);

879

if (ret != 0) {

879

if (ret != 0) {

880

if (ret < 0)

880

if (ret < 0)

881

hid_err(hid, "%s's event failed with %d\n",

881

hid_err(hid, "%s's event failed with %d\n",

882

hdrv->name, ret);

882

hdrv->name, ret);

883

return;

883

return;

884

}

884

}

885

}

885

}

886

887

if (hid->claimed & HID_CLAIMED_INPUT)

887

if (hid->claimed & HID_CLAIMED_INPUT)

888

hidinput_hid_event(hid, field, usage, value);

888

hidinput_hid_event(hid, field, usage, value);

889

if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)

889

if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)

890

hid->hiddev_hid_event(hid, field, usage, value);

890

hid->hiddev_hid_event(hid, field, usage, value);

891

}

891

}

892

893

/*

893

/*

894

* Analyse a received field, and fetch the data from it. The field

894

* Analyse a received field, and fetch the data from it. The field

895

* content is stored for next report processing (we do differential

895

* content is stored for next report processing (we do differential

896

* reporting to the layer).

896

* reporting to the layer).

897

*/

897

*/

898

899

static void hid_input_field(struct hid_device *hid, struct hid_field *field,

899

static void hid_input_field(struct hid_device *hid, struct hid_field *field,

900

__u8 *data, int interrupt)

900

__u8 *data, int interrupt)

901

{

901

{

902

unsigned n;

902

unsigned n;

903

unsigned count = field->report_count;

903

unsigned count = field->report_count;

904

unsigned offset = field->report_offset;

904

unsigned offset = field->report_offset;

905

unsigned size = field->report_size;

905

unsigned size = field->report_size;

906

__s32 min = field->logical_minimum;

906

__s32 min = field->logical_minimum;

907

__s32 max = field->logical_maximum;

907

__s32 max = field->logical_maximum;

908

__s32 *value;

908

__s32 *value;

909

910

value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC);

910

value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC);

911

if (!value)

911

if (!value)

912

return;

912

return;

913

914

for (n = 0; n < count; n++) {

914

for (n = 0; n < count; n++) {

915

916

value[n] = min < 0 ?

916

value[n] = min < 0 ?

917

snto32(extract(hid, data, offset + n * size, size),

917

snto32(extract(hid, data, offset + n * size, size),

918

size) :

918

size) :

919

extract(hid, data, offset + n * size, size);

919

extract(hid, data, offset + n * size, size);

920

921

/* Ignore report if ErrorRollOver */

921

/* Ignore report if ErrorRollOver */

922

if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&

922

if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&

923

value[n] >= min && value[n] <= max &&

923

value[n] >= min && value[n] <= max &&

924

field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)

924

field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)

925

goto exit;

925

goto exit;

926

}

926

}

927

928

for (n = 0; n < count; n++) {

928

for (n = 0; n < count; n++) {

929

930

if (HID_MAIN_ITEM_VARIABLE & field->flags) {

930

if (HID_MAIN_ITEM_VARIABLE & field->flags) {

931

hid_process_event(hid, field, &field->usage[n], value[n], interrupt);

931

hid_process_event(hid, field, &field->usage[n], value[n], interrupt);

932

continue;

932

continue;

933

}

933

}

934

935

if (field->value[n] >= min && field->value[n] <= max

935

if (field->value[n] >= min && field->value[n] <= max

936

&& field->usage[field->value[n] - min].hid

936

&& field->usage[field->value[n] - min].hid

937

&& search(value, field->value[n], count))

937

&& search(value, field->value[n], count))

938

hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);

938

hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);

939

940

if (value[n] >= min && value[n] <= max

940

if (value[n] >= min && value[n] <= max

941

&& field->usage[value[n] - min].hid

941

&& field->usage[value[n] - min].hid

942

&& search(field->value, value[n], count))

942

&& search(field->value, value[n], count))

943

hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);

943

hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);

944

}

944

}

945

946

memcpy(field->value, value, count * sizeof(__s32));

946

memcpy(field->value, value, count * sizeof(__s32));

947

exit:

947

exit:

948

kfree(value);

948

kfree(value);

949

}

949

}

950

951

/*

951

/*

952

* Output the field into the report.

952

* Output the field into the report.

953

*/

953

*/

954

955

static void hid_output_field(const struct hid_device *hid,

955

static void hid_output_field(const struct hid_device *hid,

956

struct hid_field *field, __u8 *data)

956

struct hid_field *field, __u8 *data)

957

{

957

{

958

unsigned count = field->report_count;

958

unsigned count = field->report_count;

959

unsigned offset = field->report_offset;

959

unsigned offset = field->report_offset;

960

unsigned size = field->report_size;

960

unsigned size = field->report_size;

961

unsigned n;

961

unsigned n;

962

963

for (n = 0; n < count; n++) {

963

for (n = 0; n < count; n++) {

964

if (field->logical_minimum < 0) /* signed values */

964

if (field->logical_minimum < 0) /* signed values */

965

implement(hid, data, offset + n * size, size,

965

implement(hid, data, offset + n * size, size,

966

s32ton(field->value[n], size));

966

s32ton(field->value[n], size));

967

else /* unsigned values */

967

else /* unsigned values */

968

implement(hid, data, offset + n * size, size,

968

implement(hid, data, offset + n * size, size,

969

field->value[n]);

969

field->value[n]);

970

}

970

}

971

}

971

}

972

973

/*

973

/*

974

* Create a report.

974

* Create a report.

975

*/

975

*/

976

977

void hid_output_report(struct hid_report *report, __u8 *data)

977

void hid_output_report(struct hid_report *report, __u8 *data)

978

{

978

{

979

unsigned n;

979

unsigned n;

980

981

if (report->id > 0)

981

if (report->id > 0)

982

*data++ = report->id;

982

*data++ = report->id;

983

984

memset(data, 0, ((report->size - 1) >> 3) + 1);

984

memset(data, 0, ((report->size - 1) >> 3) + 1);

985

for (n = 0; n < report->maxfield; n++)

985

for (n = 0; n < report->maxfield; n++)

986

hid_output_field(report->device, report->field[n], data);

986

hid_output_field(report->device, report->field[n], data);

987

}

987

}

988

EXPORT_SYMBOL_GPL(hid_output_report);

988

EXPORT_SYMBOL_GPL(hid_output_report);

989

990

/*

990

/*

991

* Set a field value. The report this field belongs to has to be

991

* Set a field value. The report this field belongs to has to be

992

* created and transferred to the device, to set this value in the

992

* created and transferred to the device, to set this value in the

993

* device.

993

* device.

994

*/

994

*/

995

996

int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)

996

int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)

997

{

997

{

998

unsigned size = field->report_size;

998

unsigned size = field->report_size;

999

1000

hid_dump_input(field->report->device, field->usage + offset, value);

1000

hid_dump_input(field->report->device, field->usage + offset, value);

1001

1002

if (offset >= field->report_count) {

1002

if (offset >= field->report_count) {

1003

hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",

1003

hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",

1004

offset, field->report_count);

1004

offset, field->report_count);

1005

return -1;

1005

return -1;

1006

}

1006

}

1007

if (field->logical_minimum < 0) {

1007

if (field->logical_minimum < 0) {

1008

if (value != snto32(s32ton(value, size), size)) {

1008

if (value != snto32(s32ton(value, size), size)) {

1009

hid_err(field->report->device, "value %d is out of range\n", value);

1009

hid_err(field->report->device, "value %d is out of range\n", value);

1010

return -1;

1010

return -1;

1011

}

1011

}

1012

}

1012

}

1013

field->value[offset] = value;

1013

field->value[offset] = value;

1014

return 0;

1014

return 0;

1015

}

1015

}

1016

EXPORT_SYMBOL_GPL(hid_set_field);

1016

EXPORT_SYMBOL_GPL(hid_set_field);

1017

1018

static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,

1018

static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,

1019

const u8 *data)

1019

const u8 *data)

1020

{

1020

{

1021

struct hid_report *report;

1021

struct hid_report *report;

1022

unsigned int n = 0; /* Normally report number is 0 */

1022

unsigned int n = 0; /* Normally report number is 0 */

1023

1024

/* Device uses numbered reports, data[0] is report number */

1024

/* Device uses numbered reports, data[0] is report number */

1025

if (report_enum->numbered)

1025

if (report_enum->numbered)

1026

n = *data;

1026

n = *data;

1027

1028

report = report_enum->report_id_hash[n];

1028

report = report_enum->report_id_hash[n];

1029

if (report == NULL)

1029

if (report == NULL)

1030

dbg_hid("undefined report_id %u received\n", n);

1030

dbg_hid("undefined report_id %u received\n", n);

1031

1032

return report;

1032

return report;

1033

}

1033

}

1034

1035

void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,

1035

void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,

1036

int interrupt)

1036

int interrupt)

1037

{

1037

{

1038

struct hid_report_enum *report_enum = hid->report_enum + type;

1038

struct hid_report_enum *report_enum = hid->report_enum + type;

1039

struct hid_report *report;

1039

struct hid_report *report;

1040

unsigned int a;

1040

unsigned int a;

1041

int rsize, csize = size;

1041

int rsize, csize = size;

1042

u8 *cdata = data;

1042

u8 *cdata = data;

1043

1044

report = hid_get_report(report_enum, data);

1044

report = hid_get_report(report_enum, data);

1045

if (!report)

1045

if (!report)

1046

return;

1046

return;

1047

1048

if (report_enum->numbered) {

1048

if (report_enum->numbered) {

1049

cdata++;

1049

cdata++;

1050

csize--;

1050

csize--;

1051

}

1051

}

1052

1053

rsize = ((report->size - 1) >> 3) + 1;

1053

rsize = ((report->size - 1) >> 3) + 1;

1054

1055

if (rsize > HID_MAX_BUFFER_SIZE)

1055

if (rsize > HID_MAX_BUFFER_SIZE)

1056

rsize = HID_MAX_BUFFER_SIZE;

1056

rsize = HID_MAX_BUFFER_SIZE;

1057

1058

if (csize < rsize) {

1058

if (csize < rsize) {

1059

dbg_hid("report %d is too short, (%d < %d)\n", report->id,

1059

dbg_hid("report %d is too short, (%d < %d)\n", report->id,

1060

csize, rsize);

1060

csize, rsize);

1061

memset(cdata + csize, 0, rsize - csize);

1061

memset(cdata + csize, 0, rsize - csize);

1062

}

1062

}

1063

1064

if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)

1064

if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)

1065

hid->hiddev_report_event(hid, report);

1065

hid->hiddev_report_event(hid, report);

1066

if (hid->claimed & HID_CLAIMED_HIDRAW)

1066

if (hid->claimed & HID_CLAIMED_HIDRAW)

1067

hidraw_report_event(hid, data, size);

1067

hidraw_report_event(hid, data, size);

1068

1069

for (a = 0; a < report->maxfield; a++)

1069

for (a = 0; a < report->maxfield; a++)

1070

hid_input_field(hid, report->field[a], cdata, interrupt);

1070

hid_input_field(hid, report->field[a], cdata, interrupt);

1071

1072

if (hid->claimed & HID_CLAIMED_INPUT)

1072

if (hid->claimed & HID_CLAIMED_INPUT)

1073

hidinput_report_event(hid, report);

1073

hidinput_report_event(hid, report);

1074

}

1074

}

1075

EXPORT_SYMBOL_GPL(hid_report_raw_event);

1075

EXPORT_SYMBOL_GPL(hid_report_raw_event);

1076

1077

/**

1077

/**

1078

* hid_input_report - report data from lower layer (usb, bt...)

1078

* hid_input_report - report data from lower layer (usb, bt...)

1079

*

1079

*

1080

* @hid: hid device

1080

* @hid: hid device

1081

* @type: HID report type (HID_*_REPORT)

1081

* @type: HID report type (HID_*_REPORT)

1082

* @data: report contents

1082

* @data: report contents

1083

* @size: size of data parameter

1083

* @size: size of data parameter

1084

* @interrupt: distinguish between interrupt and control transfers

1084

* @interrupt: distinguish between interrupt and control transfers

1085

*

1085

*

1086

* This is data entry for lower layers.

1086

* This is data entry for lower layers.

1087

*/

1087

*/

1088

int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)

1088

int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)

1089

{

1089

{

1090

struct hid_report_enum *report_enum;

1090

struct hid_report_enum *report_enum;

1091

struct hid_driver *hdrv;

1091

struct hid_driver *hdrv;

1092

struct hid_report *report;

1092

struct hid_report *report;

1093

char *buf;

1093

char *buf;

1094

unsigned int i;

1094

unsigned int i;

1095

int ret = 0;

1095

int ret = 0;

1096

1097

if (!hid)

1097

if (!hid)

1098

return -ENODEV;

1098

return -ENODEV;

1099

1100

if (down_trylock(&hid->driver_lock))

1100

if (down_trylock(&hid->driver_lock))

1101

return -EBUSY;

1101

return -EBUSY;

1102

1103

if (!hid->driver) {

1103

if (!hid->driver) {

1104

ret = -ENODEV;

1104

ret = -ENODEV;

1105

goto unlock;

1105

goto unlock;

1106

}

1106

}

1107

report_enum = hid->report_enum + type;

1107

report_enum = hid->report_enum + type;

1108

hdrv = hid->driver;

1108

hdrv = hid->driver;

1109

1110

if (!size) {

1110

if (!size) {

1111

dbg_hid("empty report\n");

1111

dbg_hid("empty report\n");

1112

ret = -1;

1112

ret = -1;

1113

goto unlock;

1113

goto unlock;

1114

}

1114

}

1115

1116

buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);

1116

buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);

1117

1118

if (!buf)

1118

if (!buf)

1119

goto nomem;

1119

goto nomem;

1120

1121

/* dump the report */

1121

/* dump the report */

1122

snprintf(buf, HID_DEBUG_BUFSIZE - 1,

1122

snprintf(buf, HID_DEBUG_BUFSIZE - 1,

1123

"\nreport (size %u) (%snumbered) = ", size, report_enum->numbered ? "" : "un");

1123

"\nreport (size %u) (%snumbered) = ", size, report_enum->numbered ? "" : "un");

1124

hid_debug_event(hid, buf);

1124

hid_debug_event(hid, buf);

1125

1126

for (i = 0; i < size; i++) {

1126

for (i = 0; i < size; i++) {

1127

snprintf(buf, HID_DEBUG_BUFSIZE - 1,

1127

snprintf(buf, HID_DEBUG_BUFSIZE - 1,

1128

" %02x", data[i]);

1128

" %02x", data[i]);

1129

hid_debug_event(hid, buf);

1129

hid_debug_event(hid, buf);

1130

}

1130

}

1131

hid_debug_event(hid, "\n");

1131

hid_debug_event(hid, "\n");

1132

kfree(buf);

1132

kfree(buf);

1133

1134

nomem:

1134

nomem:

1135

report = hid_get_report(report_enum, data);

1135

report = hid_get_report(report_enum, data);

1136

1137

if (!report) {

1137

if (!report) {

1138

ret = -1;

1138

ret = -1;

1139

goto unlock;

1139

goto unlock;

1140

}

1140

}

1141

1142

if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {

1142

if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {

1143

ret = hdrv->raw_event(hid, report, data, size);

1143

ret = hdrv->raw_event(hid, report, data, size);

1144

if (ret != 0) {

1144

if (ret != 0) {

1145

ret = ret < 0 ? ret : 0;

1145

ret = ret < 0 ? ret : 0;

1146

goto unlock;

1146

goto unlock;

1147

}

1147

}

1148

}

1148

}

1149

1150

hid_report_raw_event(hid, type, data, size, interrupt);

1150

hid_report_raw_event(hid, type, data, size, interrupt);

1151

1152

unlock:

1152

unlock:

1153

up(&hid->driver_lock);

1153

up(&hid->driver_lock);

1154

return ret;

1154

return ret;

1155

}

1155

}

1156

EXPORT_SYMBOL_GPL(hid_input_report);

1156

EXPORT_SYMBOL_GPL(hid_input_report);

1157

1158

static bool hid_match_one_id(struct hid_device *hdev,

1158

static bool hid_match_one_id(struct hid_device *hdev,

1159

const struct hid_device_id *id)

1159

const struct hid_device_id *id)

1160

{

1160

{

1161

return id->bus == hdev->bus &&

1161

return id->bus == hdev->bus &&

1162

(id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&

1162

(id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&

1163

(id->product == HID_ANY_ID || id->product == hdev->product);

1163

(id->product == HID_ANY_ID || id->product == hdev->product);

1164

}

1164

}

1165

1166

const struct hid_device_id *hid_match_id(struct hid_device *hdev,

1166

const struct hid_device_id *hid_match_id(struct hid_device *hdev,

1167

const struct hid_device_id *id)

1167

const struct hid_device_id *id)

1168

{

1168

{

1169

for (; id->bus; id++)

1169

for (; id->bus; id++)

1170

if (hid_match_one_id(hdev, id))

1170

if (hid_match_one_id(hdev, id))

1171

return id;

1171

return id;

1172

1173

return NULL;

1173

return NULL;

1174

}

1174

}

1175

1176

static const struct hid_device_id hid_hiddev_list[] = {

1176

static const struct hid_device_id hid_hiddev_list[] = {

1177

{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },

1177

{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },

1178

{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },

1178

{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },

1179

{ }

1179

{ }

1180

};

1180

};

1181

1182

static bool hid_hiddev(struct hid_device *hdev)

1182

static bool hid_hiddev(struct hid_device *hdev)

1183

{

1183

{

1184

return !!hid_match_id(hdev, hid_hiddev_list);

1184

return !!hid_match_id(hdev, hid_hiddev_list);

1185

}

1185

}

1186

1187

1188

static ssize_t

1188

static ssize_t

1189

read_report_descriptor(struct file *filp, struct kobject *kobj,

1189

read_report_descriptor(struct file *filp, struct kobject *kobj,

1190

struct bin_attribute *attr,

1190

struct bin_attribute *attr,

1191

char *buf, loff_t off, size_t count)

1191

char *buf, loff_t off, size_t count)

1192

{

1192

{

1193

struct device *dev = container_of(kobj, struct device, kobj);

1193

struct device *dev = container_of(kobj, struct device, kobj);

1194

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1194

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1195

1196

if (off >= hdev->rsize)

1196

if (off >= hdev->rsize)

1197

return 0;

1197

return 0;

1198

1199

if (off + count > hdev->rsize)

1199

if (off + count > hdev->rsize)

1200

count = hdev->rsize - off;

1200

count = hdev->rsize - off;

1201

1202

memcpy(buf, hdev->rdesc + off, count);

1202

memcpy(buf, hdev->rdesc + off, count);

1203

1204

return count;

1204

return count;

1205

}

1205

}

1206

1207

static struct bin_attribute dev_bin_attr_report_desc = {

1207

static struct bin_attribute dev_bin_attr_report_desc = {

1208

.attr = { .name = "report_descriptor", .mode = 0444 },

1208

.attr = { .name = "report_descriptor", .mode = 0444 },

1209

.read = read_report_descriptor,

1209

.read = read_report_descriptor,

1210

.size = HID_MAX_DESCRIPTOR_SIZE,

1210

.size = HID_MAX_DESCRIPTOR_SIZE,

1211

};

1211

};

1212

1213

int hid_connect(struct hid_device *hdev, unsigned int connect_mask)

1213

int hid_connect(struct hid_device *hdev, unsigned int connect_mask)

1214

{

1214

{

1215

static const char *types[] = { "Device", "Pointer", "Mouse", "Device",

1215

static const char *types[] = { "Device", "Pointer", "Mouse", "Device",

1216

"Joystick", "Gamepad", "Keyboard", "Keypad",

1216

"Joystick", "Gamepad", "Keyboard", "Keypad",

1217

"Multi-Axis Controller"

1217

"Multi-Axis Controller"

1218

};

1218

};

1219

const char *type, *bus;

1219

const char *type, *bus;

1220

char buf[64];

1220

char buf[64];

1221

unsigned int i;

1221

unsigned int i;

1222

int len;

1222

int len;

1223

int ret;

1223

int ret;

1224

1225

if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)

1225

if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)

1226

connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);

1226

connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);

1227

if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)

1227

if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)

1228

connect_mask |= HID_CONNECT_HIDINPUT_FORCE;

1228

connect_mask |= HID_CONNECT_HIDINPUT_FORCE;

1229

if (hdev->bus != BUS_USB)

1229

if (hdev->bus != BUS_USB)

1230

connect_mask &= ~HID_CONNECT_HIDDEV;

1230

connect_mask &= ~HID_CONNECT_HIDDEV;

1231

if (hid_hiddev(hdev))

1231

if (hid_hiddev(hdev))

1232

connect_mask |= HID_CONNECT_HIDDEV_FORCE;

1232

connect_mask |= HID_CONNECT_HIDDEV_FORCE;

1233

1234

if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,

1234

if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,

1235

connect_mask & HID_CONNECT_HIDINPUT_FORCE))

1235

connect_mask & HID_CONNECT_HIDINPUT_FORCE))

1236

hdev->claimed |= HID_CLAIMED_INPUT;

1236

hdev->claimed |= HID_CLAIMED_INPUT;

1237

if (hdev->quirks & HID_QUIRK_MULTITOUCH) {

1237

if (hdev->quirks & HID_QUIRK_MULTITOUCH) {

1238

/* this device should be handled by hid-multitouch, skip it */

1238

/* this device should be handled by hid-multitouch, skip it */

1239

return -ENODEV;

1239

return -ENODEV;

1240

}

1240

}

1241

1242

if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&

1242

if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&

1243

!hdev->hiddev_connect(hdev,

1243

!hdev->hiddev_connect(hdev,

1244

connect_mask & HID_CONNECT_HIDDEV_FORCE))

1244

connect_mask & HID_CONNECT_HIDDEV_FORCE))

1245

hdev->claimed |= HID_CLAIMED_HIDDEV;

1245

hdev->claimed |= HID_CLAIMED_HIDDEV;

1246

if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))

1246

if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))

1247

hdev->claimed |= HID_CLAIMED_HIDRAW;

1247

hdev->claimed |= HID_CLAIMED_HIDRAW;

1248

1249

if (!hdev->claimed) {

1249

if (!hdev->claimed) {

1250

hid_err(hdev, "claimed by neither input, hiddev nor hidraw\n");

1250

hid_err(hdev, "claimed by neither input, hiddev nor hidraw\n");

1251

return -ENODEV;

1251

return -ENODEV;

1252

}

1252

}

1253

1254

if ((hdev->claimed & HID_CLAIMED_INPUT) &&

1254

if ((hdev->claimed & HID_CLAIMED_INPUT) &&

1255

(connect_mask & HID_CONNECT_FF) && hdev->ff_init)

1255

(connect_mask & HID_CONNECT_FF) && hdev->ff_init)

1256

hdev->ff_init(hdev);

1256

hdev->ff_init(hdev);

1257

1258

len = 0;

1258

len = 0;

1259

if (hdev->claimed & HID_CLAIMED_INPUT)

1259

if (hdev->claimed & HID_CLAIMED_INPUT)

1260

len += sprintf(buf + len, "input");

1260

len += sprintf(buf + len, "input");

1261

if (hdev->claimed & HID_CLAIMED_HIDDEV)

1261

if (hdev->claimed & HID_CLAIMED_HIDDEV)

1262

len += sprintf(buf + len, "%shiddev%d", len ? "," : "",

1262

len += sprintf(buf + len, "%shiddev%d", len ? "," : "",

1263

hdev->minor);

1263

hdev->minor);

1264

if (hdev->claimed & HID_CLAIMED_HIDRAW)

1264

if (hdev->claimed & HID_CLAIMED_HIDRAW)

1265

len += sprintf(buf + len, "%shidraw%d", len ? "," : "",

1265

len += sprintf(buf + len, "%shidraw%d", len ? "," : "",

1266

((struct hidraw *)hdev->hidraw)->minor);

1266

((struct hidraw *)hdev->hidraw)->minor);

1267

1268

type = "Device";

1268

type = "Device";

1269

for (i = 0; i < hdev->maxcollection; i++) {

1269

for (i = 0; i < hdev->maxcollection; i++) {

1270

struct hid_collection *col = &hdev->collection[i];

1270

struct hid_collection *col = &hdev->collection[i];

1271

if (col->type == HID_COLLECTION_APPLICATION &&

1271

if (col->type == HID_COLLECTION_APPLICATION &&

1272

(col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&

1272

(col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&

1273

(col->usage & 0xffff) < ARRAY_SIZE(types)) {

1273

(col->usage & 0xffff) < ARRAY_SIZE(types)) {

1274

type = types[col->usage & 0xffff];

1274

type = types[col->usage & 0xffff];

1275

break;

1275

break;

1276

}

1276

}

1277

}

1277

}

1278

1279

switch (hdev->bus) {

1279

switch (hdev->bus) {

1280

case BUS_USB:

1280

case BUS_USB:

1281

bus = "USB";

1281

bus = "USB";

1282

break;

1282

break;

1283

case BUS_BLUETOOTH:

1283

case BUS_BLUETOOTH:

1284

bus = "BLUETOOTH";

1284

bus = "BLUETOOTH";

1285

break;

1285

break;

1286

default:

1286

default:

1287

bus = "<UNKNOWN>";

1287

bus = "<UNKNOWN>";

1288

}

1288

}

1289

1290

ret = device_create_bin_file(&hdev->dev, &dev_bin_attr_report_desc);

1290

ret = device_create_bin_file(&hdev->dev, &dev_bin_attr_report_desc);

1291

if (ret)

1291

if (ret)

1292

hid_warn(hdev,

1292

hid_warn(hdev,

1293

"can't create sysfs report descriptor attribute err: %d\n", ret);

1293

"can't create sysfs report descriptor attribute err: %d\n", ret);

1294

1295

hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",

1295

hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",

1296

buf, bus, hdev->version >> 8, hdev->version & 0xff,

1296

buf, bus, hdev->version >> 8, hdev->version & 0xff,

1297

type, hdev->name, hdev->phys);

1297

type, hdev->name, hdev->phys);

1298

1299

return 0;

1299

return 0;

1300

}

1300

}

1301

EXPORT_SYMBOL_GPL(hid_connect);

1301

EXPORT_SYMBOL_GPL(hid_connect);

1302

1303

void hid_disconnect(struct hid_device *hdev)

1303

void hid_disconnect(struct hid_device *hdev)

1304

{

1304

{

1305

device_remove_bin_file(&hdev->dev, &dev_bin_attr_report_desc);

1305

device_remove_bin_file(&hdev->dev, &dev_bin_attr_report_desc);

1306

if (hdev->claimed & HID_CLAIMED_INPUT)

1306

if (hdev->claimed & HID_CLAIMED_INPUT)

1307

hidinput_disconnect(hdev);

1307

hidinput_disconnect(hdev);

1308

if (hdev->claimed & HID_CLAIMED_HIDDEV)

1308

if (hdev->claimed & HID_CLAIMED_HIDDEV)

1309

hdev->hiddev_disconnect(hdev);

1309

hdev->hiddev_disconnect(hdev);

1310

if (hdev->claimed & HID_CLAIMED_HIDRAW)

1310

if (hdev->claimed & HID_CLAIMED_HIDRAW)

1311

hidraw_disconnect(hdev);

1311

hidraw_disconnect(hdev);

1312

}

1312

}

1313

EXPORT_SYMBOL_GPL(hid_disconnect);

1313

EXPORT_SYMBOL_GPL(hid_disconnect);

1314

1315

/* a list of devices for which there is a specialized driver on HID bus */

1315

/* a list of devices for which there is a specialized driver on HID bus */

1316

static const struct hid_device_id hid_have_special_driver[] = {

1316

static const struct hid_device_id hid_have_special_driver[] = {

1317

{ HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M1968) },

1317

{ HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M1968) },

1318

{ HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M2256) },

1318

{ HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M2256) },

1319

{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },

1319

{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },

1320

{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },

1320

{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },

1321

{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },

1321

{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },

1322

{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },

1322

{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },

1323

{ HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR, USB_DEVICE_ID_ACTIONSTAR_1011) },

1323

{ HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR, USB_DEVICE_ID_ACTIONSTAR_1011) },

1324

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },

1324

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },

1325

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },

1325

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },

1326

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },

1326

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },

1327

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },

1327

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },

1328

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },

1328

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },

1329

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },

1329

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },

1330

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },

1330

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },

1331

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },

1331

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },

1332

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },

1332

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },

1333

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },

1333

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },

1334

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },

1334

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },

1335

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },

1335

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },

1336

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },

1336

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },

1337

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },

1337

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },

1338

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },

1338

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },

1339

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },

1339

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },

1340

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI) },

1340

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI) },

1341

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO) },

1341

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO) },

1342

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS) },

1342

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS) },

1343

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI) },

1343

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI) },

1344

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO) },

1344

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO) },

1345

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS) },

1345

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS) },

1346

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },

1346

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },

1347

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },

1347

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },

1348

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },

1348

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },

1349

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },

1349

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },

1350

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },

1350

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },

1351

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },

1351

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },

1352

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },

1352

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },

1353

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },

1353

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },

1354

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },

1354

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },

1355

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },

1355

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },

1356

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },

1356

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },

1357

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },

1357

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },

1358

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },

1358

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },

1359

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },

1359

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },

1360

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },

1360

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },

1361

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },

1361

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },

1362

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },

1362

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },

1363

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },

1363

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },

1364

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },

1364

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },

1365

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },

1365

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },

1366

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },

1366

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },

1367

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },

1367

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },

1368

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },

1368

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },

1369

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },

1369

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },

1370

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },

1370

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },

1371

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },

1371

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },

1372

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },

1372

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },

1373

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },

1373

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },

1374

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },

1374

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },

1375

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },

1375

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },

1376

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },

1376

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },

1377

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },

1377

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },

1378

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },

1378

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },

1379

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },

1379

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },

1380

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },

1380

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },

1381

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },

1381

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },

1382

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },

1382

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },

1383

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },

1383

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },

1384

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },

1384

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },

1385

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },

1385

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },

1386

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },

1386

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },

1387

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },

1387

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },

1388

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) },

1388

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) },

1389

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },

1389

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },

1390

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },

1390

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },

1391

{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT) },

1391

{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT) },

1392

{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },

1392

{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },

1393

{ HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },

1393

{ HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },

1394

{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },

1394

{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },

1395

{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },

1395

{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },

1396

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },

1396

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },

1397

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH) },

1397

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH) },

1398

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },

1398

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },

1399

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },

1399

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },

1400

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },

1400

{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },

1401

{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },

1401

{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },

1402

{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },

1402

{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },

1403

{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },

1403

{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },

1404

{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },

1404

{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },

1405

{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },

1405

{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },

1406

{ HID_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },

1406

{ HID_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },

1407

{ HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },

1407

{ HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },

1408

{ HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, USB_DEVICE_ID_CVTOUCH_SCREEN) },

1408

{ HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, USB_DEVICE_ID_CVTOUCH_SCREEN) },

1409

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },

1409

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },

1410

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },

1410

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },

1411

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },

1411

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },

1412

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },

1412

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },

1413

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_TRUETOUCH) },

1413

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_TRUETOUCH) },

1414

{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },

1414

{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },

1415

{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },

1415

{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },

1416

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },

1416

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },

1417

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },

1417

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },

1418

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },

1418

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },

1419

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },

1419

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },

1420

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },

1420

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },

1421

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },

1421

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },

1422

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },

1422

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },

1423

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },

1423

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },

1424

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },

1424

{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },

1425

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },

1425

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },

1426

{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2515) },

1426

{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2515) },

1427

{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },

1427

{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },

1428

{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },

1428

{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },

1429

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_FRUCTEL, USB_DEVICE_ID_GAMETEL_MT_MODE) },

1429

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_FRUCTEL, USB_DEVICE_ID_GAMETEL_MT_MODE) },

1430

{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },

1430

{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },

1431

{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },

1431

{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },

1432

{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },

1432

{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },

1433

{ HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, USB_DEVICE_ID_GOODTOUCH_000f) },

1433

{ HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, USB_DEVICE_ID_GOODTOUCH_000f) },

1434

{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },

1434

{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },

1435

{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },

1435

{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },

1436

{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },

1436

{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },

1437

{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },

1437

{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },

1438

{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },

1438

{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },

1439

{ HID_USB_DEVICE(USB_VENDOR_ID_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) },

1439

{ HID_USB_DEVICE(USB_VENDOR_ID_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) },

1440

{ HID_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },

1440

{ HID_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },

1441

{ HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM, USB_DEVICE_ID_IDEACOM_IDC6650) },

1441

{ HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM, USB_DEVICE_ID_IDEACOM_IDC6650) },

1442

{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },

1442

{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },

1443

{ HID_USB_DEVICE(USB_VENDOR_ID_ILITEK, USB_DEVICE_ID_ILITEK_MULTITOUCH) },

1443

{ HID_USB_DEVICE(USB_VENDOR_ID_ILITEK, USB_DEVICE_ID_ILITEK_MULTITOUCH) },

1444

{ HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },

1444

{ HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },

1445

{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },

1445

{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },

1446

{ HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },

1446

{ HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },

1447

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },

1447

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },

1448

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },

1448

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },

1449

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },

1449

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },

1450

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },

1450

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },

1451

{ HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },

1451

{ HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },

1452

{ HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },

1452

{ HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },

1453

{ HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MULTITOUCH) },

1453

{ HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MULTITOUCH) },

1454

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },

1454

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },

1455

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },

1455

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },

1456

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },

1456

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },

1457

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },

1457

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },

1458

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },

1458

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },

1459

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },

1459

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },

1460

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },

1460

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },

1461

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD) },

1461

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD) },

1462

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) },

1462

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) },

1463

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) },

1463

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) },

1464

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL) },

1464

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL) },

1465

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD) },

1465

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD) },

1466

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },

1466

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },

1467

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },

1467

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },

1468

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },

1468

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },

1469

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },

1469

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },

1470

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },

1470

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },

1471

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940) },

1471

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940) },

1472

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },

1472

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },

1473

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },

1473

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },

1474

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) },

1474

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) },

1475

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },

1475

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },

1476

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },

1476

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },

1477

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },

1477

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },

1478

#if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)

1478

#if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)

1479

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },

1479

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },

1480

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },

1480

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },

1481

#endif

1481

#endif

1482

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },

1482

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },

1483

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },

1483

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },

1484

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },

1484

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },

1485

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },

1485

{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },

1486

{ HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, USB_DEVICE_ID_CRYSTALTOUCH) },

1486

{ HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, USB_DEVICE_ID_CRYSTALTOUCH) },

1487

{ HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },

1487

{ HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },

1488

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },

1488

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },

1489

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },

1489

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },

1490

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },

1490

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },

1491

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },

1491

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },

1492

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },

1492

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },

1493

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K) },

1493

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K) },

1494

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) },

1494

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) },

1495

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K) },

1495

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K) },

1496

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },

1496

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },

1497

{ HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },

1497

{ HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },

1498

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },

1498

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },

1499

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },

1499

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },

1500

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },

1500

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },

1501

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3) },

1501

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3) },

1502

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4) },

1502

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4) },

1503

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5) },

1503

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5) },

1504

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6) },

1504

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6) },

1505

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7) },

1505

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7) },

1506

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8) },

1506

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8) },

1507

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9) },

1507

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9) },

1508

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10) },

1508

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10) },

1509

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11) },

1509

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11) },

1510

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12) },

1510

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12) },

1511

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13) },

1511

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13) },

1512

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14) },

1512

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14) },

1513

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15) },

1513

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15) },

1514

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },

1514

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },

1515

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },

1515

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },

1516

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },

1516

{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },

1517

{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },

1517

{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },

1518

{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },

1518

{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },

1519

{ HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT780) },

1519

{ HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT780) },

1520

{ HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT880) },

1520

{ HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT880) },

1521

{ HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_PCI) },

1521

{ HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_PCI) },

1522

{ HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },

1522

{ HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },

1523

{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },

1523

{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },

1524

{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },

1524

{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },

1525

{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },

1525

{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },

1526

{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },

1526

{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },

1527

{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },

1527

{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },

1528

{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },

1528

{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },

1529

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },

1529

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },

1530

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },

1530

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },

1531

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },

1531

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },

1532

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },

1532

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },

1533

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) },

1533

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) },

1534

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },

1534

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },

1535

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) },

1535

{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) },

1536

{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },

1536

{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },

1537

{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },

1537

{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },

1538

{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },

1538

{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },

1539

{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },

1539

{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },

1540

{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },

1540

{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },

1541

{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },

1541

{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },

1542

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },

1542

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },

1543

{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },

1543

{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },

1544

{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM, USB_DEVICE_ID_MTP) },

1544

{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM, USB_DEVICE_ID_MTP) },

1545

{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, USB_DEVICE_ID_MTP_STM) },

1545

{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, USB_DEVICE_ID_MTP_STM) },

1546

{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX, USB_DEVICE_ID_MTP_SITRONIX) },

1546

{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX, USB_DEVICE_ID_MTP_SITRONIX) },

1547

{ HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },

1547

{ HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },

1548

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },

1548

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },

1549

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },

1549

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },

1550

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },

1550

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },

1551

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb324) },

1551

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb324) },

1552

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },

1552

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },

1553

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },

1553

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },

1554

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },

1554

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },

1555

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },

1555

{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },

1556

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) },

1556

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) },

1557

{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },

1557

{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },

1558

{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },

1558

{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },

1559

{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },

1559

{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },

1560

{ HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },

1560

{ HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },

1561

{ HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },

1561

{ HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },

1562

{ HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },

1562

{ HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },

1563

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },

1563

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },

1564

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },

1564

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },

1565

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },

1565

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },

1566

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },

1566

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },

1567

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },

1567

{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },

1568

{ HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },

1568

{ HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },

1569

{ HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },

1569

{ HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },

1570

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },

1570

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },

1571

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },

1571

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },

1572

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },

1572

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },

1573

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },

1573

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },

1574

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },

1574

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },

1575

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },

1575

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },

1576

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },

1576

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },

1577

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },

1577

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },

1578

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },

1578

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },

1579

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },

1579

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },

1580

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },

1580

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },

1581

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_PID_0038) },

1581

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_PID_0038) },

1582

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },

1582

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },

1583

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },

1583

{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },

1584

{ HID_USB_DEVICE(USB_VENDOR_ID_XAT, USB_DEVICE_ID_XAT_CSR) },

1584

{ HID_USB_DEVICE(USB_VENDOR_ID_XAT, USB_DEVICE_ID_XAT_CSR) },

1585

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX) },

1585

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX) },

1586

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX) },

1586

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX) },

1587

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR) },

1587

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR) },

1588

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX1) },

1588

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX1) },

1589

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX1) },

1589

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX1) },

1590

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR1) },

1590

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR1) },

1591

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX2) },

1591

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX2) },

1592

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX2) },

1592

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX2) },

1593

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR2) },

1593

{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR2) },

1594

{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },

1594

{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },

1595

{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },

1595

{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },

1596

{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },

1596

{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },

1597

{ HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },

1597

{ HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },

1598

1599

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },

1599

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },

1600

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },

1600

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },

1601

{ }

1601

{ }

1602

};

1602

};

1603

1604

struct hid_dynid {

1604

struct hid_dynid {

1605

struct list_head list;

1605

struct list_head list;

1606

struct hid_device_id id;

1606

struct hid_device_id id;

1607

};

1607

};

1608

1609

/**

1609

/**

1610

* store_new_id - add a new HID device ID to this driver and re-probe devices

1610

* store_new_id - add a new HID device ID to this driver and re-probe devices

1611

* @driver: target device driver

1611

* @driver: target device driver

1612

* @buf: buffer for scanning device ID data

1612

* @buf: buffer for scanning device ID data

1613

* @count: input size

1613

* @count: input size

1614

*

1614

*

1615

* Adds a new dynamic hid device ID to this driver,

1615

* Adds a new dynamic hid device ID to this driver,

1616

* and causes the driver to probe for all devices again.

1616

* and causes the driver to probe for all devices again.

1617

*/

1617

*/

1618

static ssize_t store_new_id(struct device_driver *drv, const char *buf,

1618

static ssize_t store_new_id(struct device_driver *drv, const char *buf,

1619

size_t count)

1619

size_t count)

1620

{

1620

{

1621

struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);

1621

struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);

1622

struct hid_dynid *dynid;

1622

struct hid_dynid *dynid;

1623

__u32 bus, vendor, product;

1623

__u32 bus, vendor, product;

1624

unsigned long driver_data = 0;

1624

unsigned long driver_data = 0;

1625

int ret;

1625

int ret;

1626

1627

ret = sscanf(buf, "%x %x %x %lx",

1627

ret = sscanf(buf, "%x %x %x %lx",

1628

&bus, &vendor, &product, &driver_data);

1628

&bus, &vendor, &product, &driver_data);

1629

if (ret < 3)

1629

if (ret < 3)

1630

return -EINVAL;

1630

return -EINVAL;

1631

1632

dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);

1632

dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);

1633

if (!dynid)

1633

if (!dynid)

1634

return -ENOMEM;

1634

return -ENOMEM;

1635

1636

dynid->id.bus = bus;

1636

dynid->id.bus = bus;

1637

dynid->id.vendor = vendor;

1637

dynid->id.vendor = vendor;

1638

dynid->id.product = product;

1638

dynid->id.product = product;

1639

dynid->id.driver_data = driver_data;

1639

dynid->id.driver_data = driver_data;

1640

1641

spin_lock(&hdrv->dyn_lock);

1641

spin_lock(&hdrv->dyn_lock);

1642

list_add_tail(&dynid->list, &hdrv->dyn_list);

1642

list_add_tail(&dynid->list, &hdrv->dyn_list);

1643

spin_unlock(&hdrv->dyn_lock);

1643

spin_unlock(&hdrv->dyn_lock);

1644

1645

ret = driver_attach(&hdrv->driver);

1645

ret = driver_attach(&hdrv->driver);

1646

1647

return ret ? : count;

1647

return ret ? : count;

1648

}

1648

}

1649

static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);

1649

static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);

1650

1651

static void hid_free_dynids(struct hid_driver *hdrv)

1651

static void hid_free_dynids(struct hid_driver *hdrv)

1652

{

1652

{

1653

struct hid_dynid *dynid, *n;

1653

struct hid_dynid *dynid, *n;

1654

1655

spin_lock(&hdrv->dyn_lock);

1655

spin_lock(&hdrv->dyn_lock);

1656

list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {

1656

list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {

1657

list_del(&dynid->list);

1657

list_del(&dynid->list);

1658

kfree(dynid);

1658

kfree(dynid);

1659

}

1659

}

1660

spin_unlock(&hdrv->dyn_lock);

1660

spin_unlock(&hdrv->dyn_lock);

1661

}

1661

}

1662

1663

static const struct hid_device_id *hid_match_device(struct hid_device *hdev,

1663

static const struct hid_device_id *hid_match_device(struct hid_device *hdev,

1664

struct hid_driver *hdrv)

1664

struct hid_driver *hdrv)

1665

{

1665

{

1666

struct hid_dynid *dynid;

1666

struct hid_dynid *dynid;

1667

1668

spin_lock(&hdrv->dyn_lock);

1668

spin_lock(&hdrv->dyn_lock);

1669

list_for_each_entry(dynid, &hdrv->dyn_list, list) {

1669

list_for_each_entry(dynid, &hdrv->dyn_list, list) {

1670

if (hid_match_one_id(hdev, &dynid->id)) {

1670

if (hid_match_one_id(hdev, &dynid->id)) {

1671

spin_unlock(&hdrv->dyn_lock);

1671

spin_unlock(&hdrv->dyn_lock);

1672

return &dynid->id;

1672

return &dynid->id;

1673

}

1673

}

1674

}

1674

}

1675

spin_unlock(&hdrv->dyn_lock);

1675

spin_unlock(&hdrv->dyn_lock);

1676

1677

return hid_match_id(hdev, hdrv->id_table);

1677

return hid_match_id(hdev, hdrv->id_table);

1678

}

1678

}

1679

1680

static int hid_bus_match(struct device *dev, struct device_driver *drv)

1680

static int hid_bus_match(struct device *dev, struct device_driver *drv)

1681

{

1681

{

1682

struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);

1682

struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);

1683

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1683

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1684

1685

if ((hdev->quirks & HID_QUIRK_MULTITOUCH) &&

1685

if ((hdev->quirks & HID_QUIRK_MULTITOUCH) &&

1686

!strncmp(hdrv->name, "hid-multitouch", 14))

1686

!strncmp(hdrv->name, "hid-multitouch", 14))

1687

return 1;

1687

return 1;

1688

1689

if (!hid_match_device(hdev, hdrv))

1689

if (!hid_match_device(hdev, hdrv))

1690

return 0;

1690

return 0;

1691

1692

/* generic wants all that don't have specialized driver */

1692

/* generic wants all that don't have specialized driver */

1693

if (!strncmp(hdrv->name, "generic-", 8) && !hid_ignore_special_drivers)

1693

if (!strncmp(hdrv->name, "generic-", 8) && !hid_ignore_special_drivers)

1694

return !hid_match_id(hdev, hid_have_special_driver);

1694

return !hid_match_id(hdev, hid_have_special_driver);

1695

1696

return 1;

1696

return 1;

1697

}

1697

}

1698

1699

static int hid_device_probe(struct device *dev)

1699

static int hid_device_probe(struct device *dev)

1700

{

1700

{

1701

struct hid_driver *hdrv = container_of(dev->driver,

1701

struct hid_driver *hdrv = container_of(dev->driver,

1702

struct hid_driver, driver);

1702

struct hid_driver, driver);

1703

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1703

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1704

const struct hid_device_id *id;

1704

const struct hid_device_id *id;

1705

int ret = 0;

1705

int ret = 0;

1706

1707

if (down_interruptible(&hdev->driver_lock))

1707

if (down_interruptible(&hdev->driver_lock))

1708

return -EINTR;

1708

return -EINTR;

1709

1710

if (!hdev->driver) {

1710

if (!hdev->driver) {

1711

id = hid_match_device(hdev, hdrv);

1711

id = hid_match_device(hdev, hdrv);

1712

if (id == NULL) {

1712

if (id == NULL) {

1713

if (!((hdev->quirks & HID_QUIRK_MULTITOUCH) &&

1713

if (!((hdev->quirks & HID_QUIRK_MULTITOUCH) &&

1714

!strncmp(hdrv->name, "hid-multitouch", 14))) {

1714

!strncmp(hdrv->name, "hid-multitouch", 14))) {

1715

ret = -ENODEV;

1715

ret = -ENODEV;

1716

goto unlock;

1716

goto unlock;

1717

}

1717

}

1718

}

1718

}

1719

1720

hdev->driver = hdrv;

1720

hdev->driver = hdrv;

1721

if (hdrv->probe) {

1721

if (hdrv->probe) {

1722

ret = hdrv->probe(hdev, id);

1722

ret = hdrv->probe(hdev, id);

1723

} else { /* default probe */

1723

} else { /* default probe */

1724

ret = hid_parse(hdev);

1724

ret = hid_parse(hdev);

1725

if (!ret)

1725

if (!ret)

1726

ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);

1726

ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);

1727

}

1727

}

1728

if (ret)

1728

if (ret)

1729

hdev->driver = NULL;

1729

hdev->driver = NULL;

1730

}

1730

}

1731

unlock:

1731

unlock:

1732

up(&hdev->driver_lock);

1732

up(&hdev->driver_lock);

1733

return ret;

1733

return ret;

1734

}

1734

}

1735

1736

static int hid_device_remove(struct device *dev)

1736

static int hid_device_remove(struct device *dev)

1737

{

1737

{

1738

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1738

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1739

struct hid_driver *hdrv;

1739

struct hid_driver *hdrv;

1740

1741

if (down_interruptible(&hdev->driver_lock))

1741

if (down_interruptible(&hdev->driver_lock))

1742

return -EINTR;

1742

return -EINTR;

1743

1744

hdrv = hdev->driver;

1744

hdrv = hdev->driver;

1745

if (hdrv) {

1745

if (hdrv) {

1746

if (hdrv->remove)

1746

if (hdrv->remove)

1747

hdrv->remove(hdev);

1747

hdrv->remove(hdev);

1748

else /* default remove */

1748

else /* default remove */

1749

hid_hw_stop(hdev);

1749

hid_hw_stop(hdev);

1750

hdev->driver = NULL;

1750

hdev->driver = NULL;

1751

}

1751

}

1752

1753

up(&hdev->driver_lock);

1753

up(&hdev->driver_lock);

1754

return 0;

1754

return 0;

1755

}

1755

}

1756

1757

static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)

1757

static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)

1758

{

1758

{

1759

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1759

struct hid_device *hdev = container_of(dev, struct hid_device, dev);

1760

1761

if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",

1761

if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",

1762

hdev->bus, hdev->vendor, hdev->product))

1762

hdev->bus, hdev->vendor, hdev->product))

1763

return -ENOMEM;

1763

return -ENOMEM;

1764

1765

if (add_uevent_var(env, "HID_NAME=%s", hdev->name))

1765

if (add_uevent_var(env, "HID_NAME=%s", hdev->name))

1766

return -ENOMEM;

1766

return -ENOMEM;

1767

1768

if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))

1768

if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))

1769

return -ENOMEM;

1769

return -ENOMEM;

1770

1771

if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))

1771

if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))

1772

return -ENOMEM;

1772

return -ENOMEM;

1773

1774

if (add_uevent_var(env, "MODALIAS=hid:b%04Xv%08Xp%08X",

1774

if (add_uevent_var(env, "MODALIAS=hid:b%04Xv%08Xp%08X",

1775

hdev->bus, hdev->vendor, hdev->product))

1775

hdev->bus, hdev->vendor, hdev->product))

1776

return -ENOMEM;

1776

return -ENOMEM;

1777

1778

return 0;

1778

return 0;

1779

}

1779

}

1780

1781

static struct bus_type hid_bus_type = {

1781

static struct bus_type hid_bus_type = {

1782

.name = "hid",

1782

.name = "hid",

1783

.match = hid_bus_match,

1783

.match = hid_bus_match,

1784

.probe = hid_device_probe,

1784

.probe = hid_device_probe,

1785

.remove = hid_device_remove,

1785

.remove = hid_device_remove,

1786

.uevent = hid_uevent,

1786

.uevent = hid_uevent,

1787

};

1787

};

1788

1789

/* a list of devices that shouldn't be handled by HID core at all */

1789

/* a list of devices that shouldn't be handled by HID core at all */

1790

static const struct hid_device_id hid_ignore_list[] = {

1790

static const struct hid_device_id hid_ignore_list[] = {

1791

{ HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR) },

1791

{ HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR) },

1792

{ HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302) },

1792

{ HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302) },

1793

{ HID_USB_DEVICE(USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X) },

1793

{ HID_USB_DEVICE(USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X) },

1794

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01) },

1794

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01) },

1795

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10) },

1795

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10) },

1796

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20) },

1796

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20) },

1797

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21) },

1797

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21) },

1798

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22) },

1798

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22) },

1799

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23) },

1799

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23) },

1800

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24) },

1800

{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24) },

1801

{ HID_USB_DEVICE(USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1) },

1801

{ HID_USB_DEVICE(USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1) },

1802

{ HID_USB_DEVICE(USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232) },

1802

{ HID_USB_DEVICE(USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232) },

1803

{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},

1803

{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},

1804

{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},

1804

{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},

1805

{ HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },

1805

{ HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },

1806

{ HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },

1806

{ HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },

1807

{ HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },

1807

{ HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },

1808

{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X) },

1808

{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X) },

1809

{ HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109) },

1809

{ HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109) },

1810

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM) },

1810

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM) },

1811

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE) },

1811

{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE) },

1812

{ HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },

1812

{ HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },

1813

{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },

1813

{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },

1814

{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },

1814

{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },

1815

{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x0004) },

1815

{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x0004) },

1816

{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x000a) },

1816

{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x000a) },

1817

{ HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },

1817

{ HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },

1818

{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },

1818

{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },

1819

{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },

1819

{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },

1820

{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },

1820

{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },

1821

{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },

1821

{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },

1822

{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },

1822

{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },

1823

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30) },

1823

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30) },

1824

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30) },

1824

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30) },

1825

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT) },

1825

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT) },

1826

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT) },

1826

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT) },

1827

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT) },

1827

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT) },

1828

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT) },

1828

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT) },

1829

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT) },

1829

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT) },

1830

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL) },

1830

{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL) },

1831

{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2) },

1831

{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2) },

1832

{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN) },

1832

{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN) },

1833

{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER) },

1833

{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER) },

1834

{ HID_USB_DEVICE(USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY) },

1834

{ HID_USB_DEVICE(USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY) },

1835

{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE) },

1835

{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE) },

1836

{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB) },

1836

{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB) },

1837

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90) },

1837

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90) },

1838

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100) },

1838

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100) },

1839

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101) },

1839

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101) },

1840

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103) },

1840

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103) },

1841

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104) },

1841

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104) },

1842

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105) },

1842

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105) },

1843

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106) },

1843

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106) },

1844

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107) },

1844

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107) },

1845

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108) },

1845

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108) },

1846

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200) },

1846

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200) },

1847

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201) },

1847

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201) },

1848

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202) },

1848

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202) },

1849

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203) },

1849

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203) },

1850

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204) },

1850

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204) },

1851

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205) },

1851

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205) },

1852

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206) },

1852

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206) },

1853

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207) },

1853

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207) },

1854

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300) },

1854

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300) },

1855

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301) },

1855

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301) },

1856

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302) },

1856

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302) },

1857

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303) },

1857

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303) },

1858

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304) },

1858

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304) },

1859

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305) },

1859

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305) },

1860

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306) },

1860

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306) },

1861

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307) },

1861

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307) },

1862

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308) },

1862

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308) },

1863

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309) },

1863

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309) },

1864

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400) },

1864

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400) },

1865

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401) },

1865

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401) },

1866

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402) },

1866

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402) },

1867

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403) },

1867

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403) },

1868

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404) },

1868

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404) },

1869

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405) },

1869

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405) },

1870

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500) },

1870

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500) },

1871

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501) },

1871

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501) },

1872

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502) },

1872

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502) },

1873

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503) },

1873

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503) },

1874

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504) },

1874

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504) },

1875

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000) },

1875

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000) },

1876

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001) },

1876

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001) },

1877

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002) },

1877

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002) },

1878

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003) },

1878

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003) },

1879

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004) },

1879

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004) },

1880

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005) },

1880

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005) },

1881

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },

1881

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },

1882

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },

1882

{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },

1883

{ HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },

1883

{ HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },

1884

{ HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },

1884

{ HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },

1885

{ HID_USB_DEVICE(USB_VENDOR_ID_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },

1885

{ HID_USB_DEVICE(USB_VENDOR_ID_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },

1886

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },

1886

{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },

1887

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_KYE, 0x0058) },

1887

{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_KYE, 0x0058) },

1888

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },

1888

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },

1889

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },

1889

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },

1890

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },

1890

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },

1891

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },

1891

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },

1892

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },

1892

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },

1893

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },

1893

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },

1894

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },

1894

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },

1895

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },

1895

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },

1896

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },

1896

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },

1897

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },

1897

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },

1898

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },

1898

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },

1899

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },

1899

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },

1900

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },

1900

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },

1901

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },

1901

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },

1902

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },

1902

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },

1903

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },

1903

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },

1904

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },

1904

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },

1905

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },

1905

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },

1906

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },

1906

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },

1907

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },

1907

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },

1908

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },

1908

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },

1909

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },

1909

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },

1910

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },

1910

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },

1911

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },

1911

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },

1912

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },

1912

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },

1913

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },

1913

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },

1914

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },

1914

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },

1915

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },

1915

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },

1916

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },

1916

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },

1917

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },

1917

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },

1918

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },

1918

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },

1919

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },

1919

{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },

1920

{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_BEATPAD) },

1920

{ HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },

1921

{ HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },

1921

{ HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },

1922

{ HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },

1922

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },

1923

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },

1923

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2) },

1924

{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2) },

1924

{ HID_USB_DEVICE(USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY) },

1925

{ HID_USB_DEVICE(USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY) },

1925

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100) },

1926

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100) },

1926

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20) },

1927

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20) },

1927

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30) },

1928

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30) },

1928

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100) },

1929

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100) },

1929

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108) },

1930

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108) },

1930

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118) },

1931

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118) },

1931

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200) },

1932

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200) },

1932

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300) },

1933

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300) },

1933

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400) },

1934

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400) },

1934

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500) },

1935

{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500) },

1935

{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0001) },

1936

{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0001) },

1936

{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0002) },

1937

{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0002) },

1937

{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0003) },

1938

{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0003) },

1938

{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },

1939

{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },

1939

{ HID_USB_DEVICE(USB_VENDOR_ID_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },

1940

{ HID_USB_DEVICE(USB_VENDOR_ID_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },

1940

{ HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },

1941

{ HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },

1941

#if defined(CONFIG_MOUSE_SYNAPTICS_USB) || defined(CONFIG_MOUSE_SYNAPTICS_USB_MODULE)

1942

#if defined(CONFIG_MOUSE_SYNAPTICS_USB) || defined(CONFIG_MOUSE_SYNAPTICS_USB_MODULE)

1942

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP) },

1943

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP) },

1943

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_INT_TP) },

1944

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_INT_TP) },

1944

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_CPAD) },

1945

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_CPAD) },

1945

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_STICK) },

1946

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_STICK) },

1946

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WP) },

1947

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WP) },

1947

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_COMP_TP) },

1948

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_COMP_TP) },

1948

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WTP) },

1949

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WTP) },

1949

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DPAD) },

1950

{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DPAD) },

1950

#endif

1951

#endif

1951

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },

1952

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },

1952

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },

1953

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },

1953

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },

1954

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },

1954

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },

1955

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },

1955

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },

1956

{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },

1956

{ HID_USB_DEVICE(USB_VENDOR_ID_WACOM, HID_ANY_ID) },

1957

{ HID_USB_DEVICE(USB_VENDOR_ID_WACOM, HID_ANY_ID) },

1957

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) },

1958

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) },

1958

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },

1959

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },

1959

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },

1960

{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },

1960

{ HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },

1961

{ HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },

1961

{ }

1962

{ }

1962

};

1963

};

1963

1964

/**

1965

/**

1965

* hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer

1966

* hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer

1966

*

1967

*

1967

* There are composite devices for which we want to ignore only a certain

1968

* There are composite devices for which we want to ignore only a certain

1968

* interface. This is a list of devices for which only the mouse interface will

1969

* interface. This is a list of devices for which only the mouse interface will

1969

* be ignored. This allows a dedicated driver to take care of the interface.

1970

* be ignored. This allows a dedicated driver to take care of the interface.

1970

*/

1971

*/

1971

static const struct hid_device_id hid_mouse_ignore_list[] = {

1972

static const struct hid_device_id hid_mouse_ignore_list[] = {

1972

/* appletouch driver */

1973

/* appletouch driver */

1973

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },

1974

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },

1974

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },

1975

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },

1975

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },

1976

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },

1976

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },

1977

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },

1977

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },

1978

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },

1978

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },

1979

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },

1979

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },

1980

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },

1980

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },

1981

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },

1981

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },

1982

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },

1982

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },

1983

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },

1983

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },

1984

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },

1984

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },

1985

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },

1985

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },

1986

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },

1986

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },

1987

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },

1987

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },

1988

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },

1988

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },

1989

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },

1989

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },

1990

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },

1990

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },

1991

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },

1991

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },

1992

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },

1992

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },

1993

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },

1993

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },

1994

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },

1994

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },

1995

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },

1995

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },

1996

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },

1996

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },

1997

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },

1997

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },

1998

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },

1998

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },

1999

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },

1999

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },

2000

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },

2000

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },

2001

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },

2001

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },

2002

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },

2002

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },

2003

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },

2003

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },

2004

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },

2004

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },

2005

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },

2005

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },

2006

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },

2006

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },

2007

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },

2007

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },

2008

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },

2008

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },

2009

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },

2009

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },

2010

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },

2010

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },

2011

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },

2011

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },

2012

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },

2012

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },

2013

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },

2013

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },

2014

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },

2014

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },

2015

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },

2015

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },

2016

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },

2016

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },

2017

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },

2017

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },

2018

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },

2018

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },

2019

{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },

2019

{ }

2020

{ }

2020

};

2021

};

2021

2022

static bool hid_ignore(struct hid_device *hdev)

2023

static bool hid_ignore(struct hid_device *hdev)

2023

{

2024

{

2024

switch (hdev->vendor) {

2025

switch (hdev->vendor) {

2025

case USB_VENDOR_ID_CODEMERCS:

2026

case USB_VENDOR_ID_CODEMERCS:

2026

/* ignore all Code Mercenaries IOWarrior devices */

2027

/* ignore all Code Mercenaries IOWarrior devices */

2027

if (hdev->product >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&

2028

if (hdev->product >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&

2028

hdev->product <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)

2029

hdev->product <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)

2029

return true;

2030

return true;

2030

break;

2031

break;

2031

case USB_VENDOR_ID_LOGITECH:

2032

case USB_VENDOR_ID_LOGITECH:

2032

if (hdev->product >= USB_DEVICE_ID_LOGITECH_HARMONY_FIRST &&

2033

if (hdev->product >= USB_DEVICE_ID_LOGITECH_HARMONY_FIRST &&

2033

hdev->product <= USB_DEVICE_ID_LOGITECH_HARMONY_LAST)

2034

hdev->product <= USB_DEVICE_ID_LOGITECH_HARMONY_LAST)

2034

return true;

2035

return true;

2035

/*

2036

/*

2036

* The Keene FM transmitter USB device has the same USB ID as

2037

* The Keene FM transmitter USB device has the same USB ID as

2037

* the Logitech AudioHub Speaker, but it should ignore the hid.

2038

* the Logitech AudioHub Speaker, but it should ignore the hid.

2038

* Check if the name is that of the Keene device.

2039

* Check if the name is that of the Keene device.

2039

* For reference: the name of the AudioHub is

2040

* For reference: the name of the AudioHub is

2040

* "HOLTEK AudioHub Speaker".

2041

* "HOLTEK AudioHub Speaker".

2041

*/

2042

*/

2042

if (hdev->product == USB_DEVICE_ID_LOGITECH_AUDIOHUB &&

2043

if (hdev->product == USB_DEVICE_ID_LOGITECH_AUDIOHUB &&

2043

!strcmp(hdev->name, "HOLTEK B-LINK USB Audio "))

2044

!strcmp(hdev->name, "HOLTEK B-LINK USB Audio "))

2044

return true;

2045

return true;

2045

break;

2046

break;

2046

case USB_VENDOR_ID_SOUNDGRAPH:

2047

case USB_VENDOR_ID_SOUNDGRAPH:

2047

if (hdev->product >= USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST &&

2048

if (hdev->product >= USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST &&

2048

hdev->product <= USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST)

2049

hdev->product <= USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST)

2049

return true;

2050

return true;

2050

break;

2051

break;

2051

case USB_VENDOR_ID_HANWANG:

2052

case USB_VENDOR_ID_HANWANG:

2052

if (hdev->product >= USB_DEVICE_ID_HANWANG_TABLET_FIRST &&

2053

if (hdev->product >= USB_DEVICE_ID_HANWANG_TABLET_FIRST &&

2053

hdev->product <= USB_DEVICE_ID_HANWANG_TABLET_LAST)

2054

hdev->product <= USB_DEVICE_ID_HANWANG_TABLET_LAST)

2054

return true;

2055

return true;

2055

break;

2056

break;

2056

case USB_VENDOR_ID_JESS:

2057

case USB_VENDOR_ID_JESS:

2057

if (hdev->product == USB_DEVICE_ID_JESS_YUREX &&

2058

if (hdev->product == USB_DEVICE_ID_JESS_YUREX &&

2058

hdev->type == HID_TYPE_USBNONE)

2059

hdev->type == HID_TYPE_USBNONE)

2059

return true;

2060

return true;

2060

break;

2061

break;

2061

}

2062

}

2062

2063

if (hdev->type == HID_TYPE_USBMOUSE &&

2064

if (hdev->type == HID_TYPE_USBMOUSE &&

2064

hid_match_id(hdev, hid_mouse_ignore_list))

2065

hid_match_id(hdev, hid_mouse_ignore_list))

2065

return true;

2066

return true;

2066

2067

return !!hid_match_id(hdev, hid_ignore_list);

2068

return !!hid_match_id(hdev, hid_ignore_list);

2068

}

2069

}

2069

2070

int hid_add_device(struct hid_device *hdev)

2071

int hid_add_device(struct hid_device *hdev)

2071

{

2072

{

2072

static atomic_t id = ATOMIC_INIT(0);

2073

static atomic_t id = ATOMIC_INIT(0);

2073

int ret;

2074

int ret;

2074

2075

if (WARN_ON(hdev->status & HID_STAT_ADDED))

2076

if (WARN_ON(hdev->status & HID_STAT_ADDED))

2076

return -EBUSY;

2077

return -EBUSY;

2077

2078

/* we need to kill them here, otherwise they will stay allocated to

2079

/* we need to kill them here, otherwise they will stay allocated to

2079

* wait for coming driver */

2080

* wait for coming driver */

2080

if (!(hdev->quirks & HID_QUIRK_NO_IGNORE)

2081

if (!(hdev->quirks & HID_QUIRK_NO_IGNORE)

2081

&& (hid_ignore(hdev) || (hdev->quirks & HID_QUIRK_IGNORE)))

2082

&& (hid_ignore(hdev) || (hdev->quirks & HID_QUIRK_IGNORE)))

2082

return -ENODEV;

2083

return -ENODEV;

2083

2084

/* XXX hack, any other cleaner solution after the driver core

2085

/* XXX hack, any other cleaner solution after the driver core

2085

* is converted to allow more than 20 bytes as the device name? */

2086

* is converted to allow more than 20 bytes as the device name? */

2086

dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,

2087

dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,

2087

hdev->vendor, hdev->product, atomic_inc_return(&id));

2088

hdev->vendor, hdev->product, atomic_inc_return(&id));

2088

2089

hid_debug_register(hdev, dev_name(&hdev->dev));

2090

hid_debug_register(hdev, dev_name(&hdev->dev));

2090

ret = device_add(&hdev->dev);

2091

ret = device_add(&hdev->dev);

2091

if (!ret)

2092

if (!ret)

2092

hdev->status |= HID_STAT_ADDED;

2093

hdev->status |= HID_STAT_ADDED;

2093

else

2094

else

2094

hid_debug_unregister(hdev);

2095

hid_debug_unregister(hdev);

2095

2096

return ret;

2097

return ret;

2097

}

2098

}

2098

EXPORT_SYMBOL_GPL(hid_add_device);

2099

EXPORT_SYMBOL_GPL(hid_add_device);

2099

2100

/**

2101

/**

2101

* hid_allocate_device - allocate new hid device descriptor

2102

* hid_allocate_device - allocate new hid device descriptor

2102

*

2103

*

2103

* Allocate and initialize hid device, so that hid_destroy_device might be

2104

* Allocate and initialize hid device, so that hid_destroy_device might be

2104

* used to free it.

2105

* used to free it.

2105

*

2106

*

2106

* New hid_device pointer is returned on success, otherwise ERR_PTR encoded

2107

* New hid_device pointer is returned on success, otherwise ERR_PTR encoded

2107

* error value.

2108

* error value.

2108

*/

2109

*/

2109

struct hid_device *hid_allocate_device(void)

2110

struct hid_device *hid_allocate_device(void)

2110

{

2111

{

2111

struct hid_device *hdev;

2112

struct hid_device *hdev;

2112

unsigned int i;

2113

unsigned int i;

2113

int ret = -ENOMEM;

2114

int ret = -ENOMEM;

2114

2115

hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);

2116

hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);

2116

if (hdev == NULL)

2117

if (hdev == NULL)

2117

return ERR_PTR(ret);

2118

return ERR_PTR(ret);

2118

2119

device_initialize(&hdev->dev);

2120

device_initialize(&hdev->dev);

2120

hdev->dev.release = hid_device_release;

2121

hdev->dev.release = hid_device_release;

2121

hdev->dev.bus = &hid_bus_type;

2122

hdev->dev.bus = &hid_bus_type;

2122

2123

hdev->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,

2124

hdev->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,

2124

sizeof(struct hid_collection), GFP_KERNEL);

2125

sizeof(struct hid_collection), GFP_KERNEL);

2125

if (hdev->collection == NULL)

2126

if (hdev->collection == NULL)

2126

goto err;

2127

goto err;

2127

hdev->collection_size = HID_DEFAULT_NUM_COLLECTIONS;

2128

hdev->collection_size = HID_DEFAULT_NUM_COLLECTIONS;

2128

2129

for (i = 0; i < HID_REPORT_TYPES; i++)

2130

for (i = 0; i < HID_REPORT_TYPES; i++)

2130

INIT_LIST_HEAD(&hdev->report_enum[i].report_list);

2131

INIT_LIST_HEAD(&hdev->report_enum[i].report_list);

2131

2132

init_waitqueue_head(&hdev->debug_wait);

2133

init_waitqueue_head(&hdev->debug_wait);

2133

INIT_LIST_HEAD(&hdev->debug_list);

2134

INIT_LIST_HEAD(&hdev->debug_list);

2134

sema_init(&hdev->driver_lock, 1);

2135

sema_init(&hdev->driver_lock, 1);

2135

2136

return hdev;

2137

return hdev;

2137

err:

2138

err:

2138

put_device(&hdev->dev);

2139

put_device(&hdev->dev);

2139

return ERR_PTR(ret);

2140

return ERR_PTR(ret);

2140

}

2141

}

2141

EXPORT_SYMBOL_GPL(hid_allocate_device);

2142

EXPORT_SYMBOL_GPL(hid_allocate_device);

2142

2143

static void hid_remove_device(struct hid_device *hdev)

2144

static void hid_remove_device(struct hid_device *hdev)

2144

{

2145

{

2145

if (hdev->status & HID_STAT_ADDED) {

2146

if (hdev->status & HID_STAT_ADDED) {

2146

device_del(&hdev->dev);

2147

device_del(&hdev->dev);

2147

hid_debug_unregister(hdev);

2148

hid_debug_unregister(hdev);

2148

hdev->status &= ~HID_STAT_ADDED;

2149

hdev->status &= ~HID_STAT_ADDED;

2149

}

2150

}

2150

}

2151

}

2151

2152

/**

2153

/**

2153

* hid_destroy_device - free previously allocated device

2154

* hid_destroy_device - free previously allocated device

2154

*

2155

*

2155

* @hdev: hid device

2156

* @hdev: hid device

2156

*

2157

*

2157

* If you allocate hid_device through hid_allocate_device, you should ever

2158

* If you allocate hid_device through hid_allocate_device, you should ever

2158

* free by this function.

2159

* free by this function.

2159

*/

2160

*/

2160

void hid_destroy_device(struct hid_device *hdev)

2161

void hid_destroy_device(struct hid_device *hdev)

2161

{

2162

{

2162

hid_remove_device(hdev);

2163

hid_remove_device(hdev);

2163

put_device(&hdev->dev);

2164

put_device(&hdev->dev);

2164

}

2165

}

2165

EXPORT_SYMBOL_GPL(hid_destroy_device);

2166

EXPORT_SYMBOL_GPL(hid_destroy_device);

2166

2167

int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,

2168

int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,

2168

const char *mod_name)

2169

const char *mod_name)

2169

{

2170

{

2170

int ret;

2171

int ret;

2171

2172

hdrv->driver.name = hdrv->name;

2173

hdrv->driver.name = hdrv->name;

2173

hdrv->driver.bus = &hid_bus_type;

2174

hdrv->driver.bus = &hid_bus_type;

2174

hdrv->driver.owner = owner;

2175

hdrv->driver.owner = owner;

2175

hdrv->driver.mod_name = mod_name;

2176

hdrv->driver.mod_name = mod_name;

2176

2177

INIT_LIST_HEAD(&hdrv->dyn_list);

2178

INIT_LIST_HEAD(&hdrv->dyn_list);

2178

spin_lock_init(&hdrv->dyn_lock);

2179

spin_lock_init(&hdrv->dyn_lock);

2179

2180

ret = driver_register(&hdrv->driver);

2181

ret = driver_register(&hdrv->driver);

2181

if (ret)

2182

if (ret)

2182

return ret;

2183

return ret;

2183

2184

ret = driver_create_file(&hdrv->driver, &driver_attr_new_id);

2185

ret = driver_create_file(&hdrv->driver, &driver_attr_new_id);

2185

if (ret)

2186

if (ret)

2186

driver_unregister(&hdrv->driver);

2187

driver_unregister(&hdrv->driver);

2187

2188

return ret;

2189

return ret;

2189

}

2190

}

2190

EXPORT_SYMBOL_GPL(__hid_register_driver);

2191

EXPORT_SYMBOL_GPL(__hid_register_driver);

2191

2192

void hid_unregister_driver(struct hid_driver *hdrv)

2193

void hid_unregister_driver(struct hid_driver *hdrv)

2193

{

2194

{

2194

driver_remove_file(&hdrv->driver, &driver_attr_new_id);

2195

driver_remove_file(&hdrv->driver, &driver_attr_new_id);

2195

driver_unregister(&hdrv->driver);

2196

driver_unregister(&hdrv->driver);

2196

hid_free_dynids(hdrv);

2197

hid_free_dynids(hdrv);

2197

}

2198

}

2198

EXPORT_SYMBOL_GPL(hid_unregister_driver);

2199

EXPORT_SYMBOL_GPL(hid_unregister_driver);

2199

2200

int hid_check_keys_pressed(struct hid_device *hid)

2201

int hid_check_keys_pressed(struct hid_device *hid)

2201

{

2202

{

2202

struct hid_input *hidinput;

2203

struct hid_input *hidinput;

2203

int i;

2204

int i;

2204

2205

if (!(hid->claimed & HID_CLAIMED_INPUT))

2206

if (!(hid->claimed & HID_CLAIMED_INPUT))

2206

return 0;

2207

return 0;

2207

2208

list_for_each_entry(hidinput, &hid->inputs, list) {

2209

list_for_each_entry(hidinput, &hid->inputs, list) {

2209

for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)

2210

for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)

2210

if (hidinput->input->key[i])

2211

if (hidinput->input->key[i])

2211

return 1;

2212

return 1;

2212

}

2213

}

2213

2214

return 0;

2215

return 0;

2215

}

2216

}

2216

2217

EXPORT_SYMBOL_GPL(hid_check_keys_pressed);

2218

EXPORT_SYMBOL_GPL(hid_check_keys_pressed);

2218

2219

static int __init hid_init(void)

2220

static int __init hid_init(void)

2220

{

2221

{

2221

int ret;

2222

int ret;

2222

2223

if (hid_debug)

2224

if (hid_debug)

2224

pr_warn("hid_debug is now used solely for parser and driver debugging.\n"

2225

pr_warn("hid_debug is now used solely for parser and driver debugging.\n"

2225

"debugfs is now used for inspecting the device (report descriptor, reports)\n");

2226

"debugfs is now used for inspecting the device (report descriptor, reports)\n");

2226

2227

ret = bus_register(&hid_bus_type);

2228

ret = bus_register(&hid_bus_type);

2228

if (ret) {

2229

if (ret) {

2229

pr_err("can't register hid bus\n");

2230

pr_err("can't register hid bus\n");

2230

goto err;

2231

goto err;

2231

}

2232

}

2232

2233

ret = hidraw_init();

2234

ret = hidraw_init();

2234

if (ret)

2235

if (ret)

2235

goto err_bus;

2236

goto err_bus;

2236

2237

hid_debug_init();

2238

hid_debug_init();

2238

2239

return 0;

2240

return 0;

2240

err_bus:

2241

err_bus:

2241

bus_unregister(&hid_bus_type);

2242

bus_unregister(&hid_bus_type);

2242

err:

2243

err:

2243

return ret;

2244

return ret;

2244

}

2245

}

2245

2246

static void __exit hid_exit(void)

2247

static void __exit hid_exit(void)

2247

{

2248

{

2248

hid_debug_exit();

2249

hid_debug_exit();

2249

hidraw_exit();

2250

hidraw_exit();

2250

bus_unregister(&hid_bus_type);

2251

bus_unregister(&hid_bus_type);

2251

}

2252

}

2252

2253

module_init(hid_init);

2254

module_init(hid_init);

2254

module_exit(hid_exit);

2255

module_exit(hid_exit);

2255

2256

MODULE_AUTHOR("Andreas Gal");

2257

MODULE_AUTHOR("Andreas Gal");

2257

MODULE_AUTHOR("Vojtech Pavlik");

2258

MODULE_AUTHOR("Vojtech Pavlik");

2258

MODULE_AUTHOR("Jiri Kosina");

2259

MODULE_AUTHOR("Jiri Kosina");

2259

MODULE_LICENSE(DRIVER_LICENSE);

2260

MODULE_LICENSE(DRIVER_LICENSE);

2260

2261

2262

GITLAB

Input: xpad - handle all variations of Mad Catz Beat Pad

 /*
  *  HID support for Linux
  *
  *  Copyright (c) 1999 Andreas Gal
  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  *  Copyright (c) 2006-2012 Jiri Kosina
  */
 /*
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/mm.h>
 #include <linux/spinlock.h>
 #include <asm/unaligned.h>
 #include <asm/byteorder.h>
 #include <linux/input.h>
 #include <linux/wait.h>
 #include <linux/vmalloc.h>
 #include <linux/sched.h>
 #include <linux/semaphore.h>
 #include <linux/hid.h>
 #include <linux/hiddev.h>
 #include <linux/hid-debug.h>
 #include <linux/hidraw.h>
 #include "hid-ids.h"
 /*
  * Version Information
  */
 #define DRIVER_DESC "HID core driver"
 #define DRIVER_LICENSE "GPL"
 int hid_debug = 0;
 module_param_named(debug, hid_debug, int, 0600);
 MODULE_PARM_DESC(debug, "toggle HID debugging messages");
 EXPORT_SYMBOL_GPL(hid_debug);
 static int hid_ignore_special_drivers = 0;
 module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600);
 MODULE_PARM_DESC(debug, "Ignore any special drivers and handle all devices by generic driver");
 /*
  * Register a new report for a device.
  */
 struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
 {
 	struct hid_report_enum *report_enum = device->report_enum + type;
 	struct hid_report *report;
 	if (report_enum->report_id_hash[id])
 		return report_enum->report_id_hash[id];
 	report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);
 	if (!report)
 		return NULL;
 	if (id != 0)
 		report_enum->numbered = 1;
 	report->id = id;
 	report->type = type;
 	report->size = 0;
 	report->device = device;
 	report_enum->report_id_hash[id] = report;
 	list_add_tail(&report->list, &report_enum->report_list);
 	return report;
 }
 EXPORT_SYMBOL_GPL(hid_register_report);
 /*
  * Register a new field for this report.
  */
 static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)
 {
 	struct hid_field *field;
 	if (report->maxfield == HID_MAX_FIELDS) {
 		hid_err(report->device, "too many fields in report\n");
 		return NULL;
 	}
 	field = kzalloc((sizeof(struct hid_field) +
 			 usages * sizeof(struct hid_usage) +
 			 values * sizeof(unsigned)), GFP_KERNEL);
 	if (!field)
 		return NULL;
 	field->index = report->maxfield++;
 	report->field[field->index] = field;
 	field->usage = (struct hid_usage *)(field + 1);
 	field->value = (s32 *)(field->usage + usages);
 	field->report = report;
 	return field;
 }
 /*
  * Open a collection. The type/usage is pushed on the stack.
  */
 static int open_collection(struct hid_parser *parser, unsigned type)
 {
 	struct hid_collection *collection;
 	unsigned usage;
 	usage = parser->local.usage[0];
 	if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
 		hid_err(parser->device, "collection stack overflow\n");
 		return -1;
 	}
 	if (parser->device->maxcollection == parser->device->collection_size) {
 		collection = kmalloc(sizeof(struct hid_collection) *
 				parser->device->collection_size * 2, GFP_KERNEL);
 		if (collection == NULL) {
 			hid_err(parser->device, "failed to reallocate collection array\n");
 			return -1;
 		}
 		memcpy(collection, parser->device->collection,
 			sizeof(struct hid_collection) *
 			parser->device->collection_size);
 		memset(collection + parser->device->collection_size, 0,
 			sizeof(struct hid_collection) *
 			parser->device->collection_size);
 		kfree(parser->device->collection);
 		parser->device->collection = collection;
 		parser->device->collection_size *= 2;
 	}
 	parser->collection_stack[parser->collection_stack_ptr++] =
 		parser->device->maxcollection;
 	collection = parser->device->collection +
 		parser->device->maxcollection++;
 	collection->type = type;
 	collection->usage = usage;
 	collection->level = parser->collection_stack_ptr - 1;
 	if (type == HID_COLLECTION_APPLICATION)
 		parser->device->maxapplication++;
 	return 0;
 }
 /*
  * Close a collection.
  */
 static int close_collection(struct hid_parser *parser)
 {
 	if (!parser->collection_stack_ptr) {
 		hid_err(parser->device, "collection stack underflow\n");
 		return -1;
 	}
 	parser->collection_stack_ptr--;
 	return 0;
 }
 /*
  * Climb up the stack, search for the specified collection type
  * and return the usage.
  */
 static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
 {
 	struct hid_collection *collection = parser->device->collection;
 	int n;
 	for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
 		unsigned index = parser->collection_stack[n];
 		if (collection[index].type == type)
 			return collection[index].usage;
 	}
 	return 0; /* we know nothing about this usage type */
 }
 /*
  * Add a usage to the temporary parser table.
  */
 static int hid_add_usage(struct hid_parser *parser, unsigned usage)
 {
 	if (parser->local.usage_index >= HID_MAX_USAGES) {
 		hid_err(parser->device, "usage index exceeded\n");
 		return -1;
 	}
 	parser->local.usage[parser->local.usage_index] = usage;
 	parser->local.collection_index[parser->local.usage_index] =
 		parser->collection_stack_ptr ?
 		parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
 	parser->local.usage_index++;
 	return 0;
 }
 /*
  * Register a new field for this report.
  */
 static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
 {
 	struct hid_report *report;
 	struct hid_field *field;
 	int usages;
 	unsigned offset;
 	int i;
 	report = hid_register_report(parser->device, report_type, parser->global.report_id);
 	if (!report) {
 		hid_err(parser->device, "hid_register_report failed\n");
 		return -1;
 	}
 	if (parser->global.logical_maximum < parser->global.logical_minimum) {
 		hid_err(parser->device, "logical range invalid %d %d\n",
 				parser->global.logical_minimum, parser->global.logical_maximum);
 		return -1;
 	}
 	offset = report->size;
 	report->size += parser->global.report_size * parser->global.report_count;
 	if (!parser->local.usage_index) /* Ignore padding fields */
 		return 0;
 	usages = max_t(int, parser->local.usage_index, parser->global.report_count);
 	field = hid_register_field(report, usages, parser->global.report_count);
 	if (!field)
 		return 0;
 	field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
 	field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
 	field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
 	for (i = 0; i < usages; i++) {
 		int j = i;
 		/* Duplicate the last usage we parsed if we have excess values */
 		if (i >= parser->local.usage_index)
 			j = parser->local.usage_index - 1;
 		field->usage[i].hid = parser->local.usage[j];
 		field->usage[i].collection_index =
 			parser->local.collection_index[j];
 	}
 	field->maxusage = usages;
 	field->flags = flags;
 	field->report_offset = offset;
 	field->report_type = report_type;
 	field->report_size = parser->global.report_size;
 	field->report_count = parser->global.report_count;
 	field->logical_minimum = parser->global.logical_minimum;
 	field->logical_maximum = parser->global.logical_maximum;
 	field->physical_minimum = parser->global.physical_minimum;
 	field->physical_maximum = parser->global.physical_maximum;
 	field->unit_exponent = parser->global.unit_exponent;
 	field->unit = parser->global.unit;
 	return 0;
 }
 /*
  * Read data value from item.
  */
 static u32 item_udata(struct hid_item *item)
 {
 	switch (item->size) {
 	case 1: return item->data.u8;
 	case 2: return item->data.u16;
 	case 4: return item->data.u32;
 	}
 	return 0;
 }
 static s32 item_sdata(struct hid_item *item)
 {
 	switch (item->size) {
 	case 1: return item->data.s8;
 	case 2: return item->data.s16;
 	case 4: return item->data.s32;
 	}
 	return 0;
 }
 /*
  * Process a global item.
  */
 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 {
 	switch (item->tag) {
 	case HID_GLOBAL_ITEM_TAG_PUSH:
 		if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
 			hid_err(parser->device, "global environment stack overflow\n");
 			return -1;
 		}
 		memcpy(parser->global_stack + parser->global_stack_ptr++,
 			&parser->global, sizeof(struct hid_global));
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_POP:
 		if (!parser->global_stack_ptr) {
 			hid_err(parser->device, "global environment stack underflow\n");
 			return -1;
 		}
 		memcpy(&parser->global, parser->global_stack +
 			--parser->global_stack_ptr, sizeof(struct hid_global));
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 		parser->global.usage_page = item_udata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
 		parser->global.logical_minimum = item_sdata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
 		if (parser->global.logical_minimum < 0)
 			parser->global.logical_maximum = item_sdata(item);
 		else
 			parser->global.logical_maximum = item_udata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
 		parser->global.physical_minimum = item_sdata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
 		if (parser->global.physical_minimum < 0)
 			parser->global.physical_maximum = item_sdata(item);
 		else
 			parser->global.physical_maximum = item_udata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
 		parser->global.unit_exponent = item_sdata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_UNIT:
 		parser->global.unit = item_udata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
 		parser->global.report_size = item_udata(item);
 		if (parser->global.report_size > 96) {
 			hid_err(parser->device, "invalid report_size %d\n",
 					parser->global.report_size);
 			return -1;
 		}
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
 		parser->global.report_count = item_udata(item);
 		if (parser->global.report_count > HID_MAX_USAGES) {
 			hid_err(parser->device, "invalid report_count %d\n",
 					parser->global.report_count);
 			return -1;
 		}
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_REPORT_ID:
 		parser->global.report_id = item_udata(item);
 		if (parser->global.report_id == 0) {
 			hid_err(parser->device, "report_id 0 is invalid\n");
 			return -1;
 		}
 		return 0;
 	default:
 		hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
 		return -1;
 	}
 }
 /*
  * Process a local item.
  */
 static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
 {
 	__u32 data;
 	unsigned n;
 	data = item_udata(item);
 	switch (item->tag) {
 	case HID_LOCAL_ITEM_TAG_DELIMITER:
 		if (data) {
 			/*
 			 * We treat items before the first delimiter
 			 * as global to all usage sets (branch 0).
 			 * In the moment we process only these global
 			 * items and the first delimiter set.
 			 */
 			if (parser->local.delimiter_depth != 0) {
 				hid_err(parser->device, "nested delimiters\n");
 				return -1;
 			}
 			parser->local.delimiter_depth++;
 			parser->local.delimiter_branch++;
 		} else {
 			if (parser->local.delimiter_depth < 1) {
 				hid_err(parser->device, "bogus close delimiter\n");
 				return -1;
 			}
 			parser->local.delimiter_depth--;
 		}
 		return 1;
 	case HID_LOCAL_ITEM_TAG_USAGE:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		return hid_add_usage(parser, data);
 	case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		parser->local.usage_minimum = data;
 		return 0;
 	case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		for (n = parser->local.usage_minimum; n <= data; n++)
 			if (hid_add_usage(parser, n)) {
 				dbg_hid("hid_add_usage failed\n");
 				return -1;
 			}
 		return 0;
 	default:
 		dbg_hid("unknown local item tag 0x%x\n", item->tag);
 		return 0;
 	}
 	return 0;
 }
 /*
  * Process a main item.
  */
 static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
 {
 	__u32 data;
 	int ret;
 	data = item_udata(item);
 	switch (item->tag) {
 	case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
 		ret = open_collection(parser, data & 0xff);
 		break;
 	case HID_MAIN_ITEM_TAG_END_COLLECTION:
 		ret = close_collection(parser);
 		break;
 	case HID_MAIN_ITEM_TAG_INPUT:
 		ret = hid_add_field(parser, HID_INPUT_REPORT, data);
 		break;
 	case HID_MAIN_ITEM_TAG_OUTPUT:
 		ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
 		break;
 	case HID_MAIN_ITEM_TAG_FEATURE:
 		ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
 		break;
 	default:
 		hid_err(parser->device, "unknown main item tag 0x%x\n", item->tag);
 		ret = 0;
 	}
 	memset(&parser->local, 0, sizeof(parser->local));	/* Reset the local parser environment */
 	return ret;
 }
 /*
  * Process a reserved item.
  */
 static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
 {
 	dbg_hid("reserved item type, tag 0x%x\n", item->tag);
 	return 0;
 }
 /*
  * Free a report and all registered fields. The field->usage and
  * field->value table's are allocated behind the field, so we need
  * only to free(field) itself.
  */
 static void hid_free_report(struct hid_report *report)
 {
 	unsigned n;
 	for (n = 0; n < report->maxfield; n++)
 		kfree(report->field[n]);
 	kfree(report);
 }
 /*
  * Free a device structure, all reports, and all fields.
  */
 static void hid_device_release(struct device *dev)
 {
 	struct hid_device *device = container_of(dev, struct hid_device, dev);
 	unsigned i, j;
 	for (i = 0; i < HID_REPORT_TYPES; i++) {
 		struct hid_report_enum *report_enum = device->report_enum + i;
 		for (j = 0; j < 256; j++) {
 			struct hid_report *report = report_enum->report_id_hash[j];
 			if (report)
 				hid_free_report(report);
 		}
 	}
 	kfree(device->rdesc);
 	kfree(device->collection);
 	kfree(device);
 }
 /*
  * Fetch a report description item from the data stream. We support long
  * items, though they are not used yet.
  */
 static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
 {
 	u8 b;
 	if ((end - start) <= 0)
 		return NULL;
 	b = *start++;
 	item->type = (b >> 2) & 3;
 	item->tag  = (b >> 4) & 15;
 	if (item->tag == HID_ITEM_TAG_LONG) {
 		item->format = HID_ITEM_FORMAT_LONG;
 		if ((end - start) < 2)
 			return NULL;
 		item->size = *start++;
 		item->tag  = *start++;
 		if ((end - start) < item->size)
 			return NULL;
 		item->data.longdata = start;
 		start += item->size;
 		return start;
 	}
 	item->format = HID_ITEM_FORMAT_SHORT;
 	item->size = b & 3;
 	switch (item->size) {
 	case 0:
 		return start;
 	case 1:
 		if ((end - start) < 1)
 			return NULL;
 		item->data.u8 = *start++;
 		return start;
 	case 2:
 		if ((end - start) < 2)
 			return NULL;
 		item->data.u16 = get_unaligned_le16(start);
 		start = (__u8 *)((__le16 *)start + 1);
 		return start;
 	case 3:
 		item->size++;
 		if ((end - start) < 4)
 			return NULL;
 		item->data.u32 = get_unaligned_le32(start);
 		start = (__u8 *)((__le32 *)start + 1);
 		return start;
 	}
 	return NULL;
 }
 /**
  * hid_parse_report - parse device report
  *
  * @device: hid device
  * @start: report start
  * @size: report size
  *
  * Parse a report description into a hid_device structure. Reports are
  * enumerated, fields are attached to these reports.
  * 0 returned on success, otherwise nonzero error value.
  */
 int hid_parse_report(struct hid_device *device, __u8 *start,
 		unsigned size)
 {
 	struct hid_parser *parser;
 	struct hid_item item;
 	__u8 *end;
 	int ret;
 	static int (*dispatch_type[])(struct hid_parser *parser,
 				      struct hid_item *item) = {
 		hid_parser_main,
 		hid_parser_global,
 		hid_parser_local,
 		hid_parser_reserved
 	};
 	if (device->driver->report_fixup)
 		start = device->driver->report_fixup(device, start, &size);
 	device->rdesc = kmemdup(start, size, GFP_KERNEL);
 	if (device->rdesc == NULL)
 		return -ENOMEM;
 	device->rsize = size;
 	parser = vzalloc(sizeof(struct hid_parser));
 	if (!parser) {
 		ret = -ENOMEM;
 		goto err;
 	}
 	parser->device = device;
 	end = start + size;
 	ret = -EINVAL;
 	while ((start = fetch_item(start, end, &item)) != NULL) {
 		if (item.format != HID_ITEM_FORMAT_SHORT) {
 			hid_err(device, "unexpected long global item\n");
 			goto err;
 		}
 		if (dispatch_type[item.type](parser, &item)) {
 			hid_err(device, "item %u %u %u %u parsing failed\n",
 				item.format, (unsigned)item.size,
 				(unsigned)item.type, (unsigned)item.tag);
 			goto err;
 		}
 		if (start == end) {
 			if (parser->collection_stack_ptr) {
 				hid_err(device, "unbalanced collection at end of report description\n");
 				goto err;
 			}
 			if (parser->local.delimiter_depth) {
 				hid_err(device, "unbalanced delimiter at end of report description\n");
 				goto err;
 			}
 			vfree(parser);
 			return 0;
 		}
 	}
 	hid_err(device, "item fetching failed at offset %d\n", (int)(end - start));
 err:
 	vfree(parser);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(hid_parse_report);
 /*
  * Convert a signed n-bit integer to signed 32-bit integer. Common
  * cases are done through the compiler, the screwed things has to be
  * done by hand.
  */
 static s32 snto32(__u32 value, unsigned n)
 {
 	switch (n) {
 	case 8:  return ((__s8)value);
 	case 16: return ((__s16)value);
 	case 32: return ((__s32)value);
 	}
 	return value & (1 << (n - 1)) ? value | (-1 << n) : value;
 }
 /*
  * Convert a signed 32-bit integer to a signed n-bit integer.
  */
 static u32 s32ton(__s32 value, unsigned n)
 {
 	s32 a = value >> (n - 1);
 	if (a && a != -1)
 		return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
 	return value & ((1 << n) - 1);
 }
 /*
  * Extract/implement a data field from/to a little endian report (bit array).
  *
  * Code sort-of follows HID spec:
  *     http://www.usb.org/developers/devclass_docs/HID1_11.pdf
  *
  * While the USB HID spec allows unlimited length bit fields in "report
  * descriptors", most devices never use more than 16 bits.
  * One model of UPS is claimed to report "LINEV" as a 32-bit field.
  * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
  */
 static __u32 extract(const struct hid_device *hid, __u8 *report,
 		     unsigned offset, unsigned n)
 {
 	u64 x;
 	if (n > 32)
 		hid_warn(hid, "extract() called with n (%d) > 32! (%s)\n",
 			 n, current->comm);
 	report += offset >> 3;  /* adjust byte index */
 	offset &= 7;            /* now only need bit offset into one byte */
 	x = get_unaligned_le64(report);
 	x = (x >> offset) & ((1ULL << n) - 1);  /* extract bit field */
 	return (u32) x;
 }
 /*
  * "implement" : set bits in a little endian bit stream.
  * Same concepts as "extract" (see comments above).
  * The data mangled in the bit stream remains in little endian
  * order the whole time. It make more sense to talk about
  * endianness of register values by considering a register
  * a "cached" copy of the little endiad bit stream.
  */
 static void implement(const struct hid_device *hid, __u8 *report,
 		      unsigned offset, unsigned n, __u32 value)
 {
 	u64 x;
 	u64 m = (1ULL << n) - 1;
 	if (n > 32)
 		hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
 			 __func__, n, current->comm);
 	if (value > m)
 		hid_warn(hid, "%s() called with too large value %d! (%s)\n",
 			 __func__, value, current->comm);
 	WARN_ON(value > m);
 	value &= m;
 	report += offset >> 3;
 	offset &= 7;
 	x = get_unaligned_le64(report);
 	x &= ~(m << offset);
 	x |= ((u64)value) << offset;
 	put_unaligned_le64(x, report);
 }
 /*
  * Search an array for a value.
  */
 static int search(__s32 *array, __s32 value, unsigned n)
 {
 	while (n--) {
 		if (*array++ == value)
 			return 0;
 	}
 	return -1;
 }
 /**
  * hid_match_report - check if driver's raw_event should be called
  *
  * @hid: hid device
  * @report_type: type to match against
  *
  * compare hid->driver->report_table->report_type to report->type
  */
 static int hid_match_report(struct hid_device *hid, struct hid_report *report)
 {
 	const struct hid_report_id *id = hid->driver->report_table;
 	if (!id) /* NULL means all */
 		return 1;
 	for (; id->report_type != HID_TERMINATOR; id++)
 		if (id->report_type == HID_ANY_ID ||
 				id->report_type == report->type)
 			return 1;
 	return 0;
 }
 /**
  * hid_match_usage - check if driver's event should be called
  *
  * @hid: hid device
  * @usage: usage to match against
  *
  * compare hid->driver->usage_table->usage_{type,code} to
  * usage->usage_{type,code}
  */
 static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
 {
 	const struct hid_usage_id *id = hid->driver->usage_table;
 	if (!id) /* NULL means all */
 		return 1;
 	for (; id->usage_type != HID_ANY_ID - 1; id++)
 		if ((id->usage_hid == HID_ANY_ID ||
 				id->usage_hid == usage->hid) &&
 				(id->usage_type == HID_ANY_ID ||
 				id->usage_type == usage->type) &&
 				(id->usage_code == HID_ANY_ID ||
 				 id->usage_code == usage->code))
 			return 1;
 	return 0;
 }
 static void hid_process_event(struct hid_device *hid, struct hid_field *field,
 		struct hid_usage *usage, __s32 value, int interrupt)
 {
 	struct hid_driver *hdrv = hid->driver;
 	int ret;
 	hid_dump_input(hid, usage, value);
 	if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
 		ret = hdrv->event(hid, field, usage, value);
 		if (ret != 0) {
 			if (ret < 0)
 				hid_err(hid, "%s's event failed with %d\n",
 						hdrv->name, ret);
 			return;
 		}
 	}
 	if (hid->claimed & HID_CLAIMED_INPUT)
 		hidinput_hid_event(hid, field, usage, value);
 	if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
 		hid->hiddev_hid_event(hid, field, usage, value);
 }
 /*
  * Analyse a received field, and fetch the data from it. The field
  * content is stored for next report processing (we do differential
  * reporting to the layer).
  */
 static void hid_input_field(struct hid_device *hid, struct hid_field *field,
 			    __u8 *data, int interrupt)
 {
 	unsigned n;
 	unsigned count = field->report_count;
 	unsigned offset = field->report_offset;
 	unsigned size = field->report_size;
 	__s32 min = field->logical_minimum;
 	__s32 max = field->logical_maximum;
 	__s32 *value;
 	value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC);
 	if (!value)
 		return;
 	for (n = 0; n < count; n++) {
 		value[n] = min < 0 ?
 			snto32(extract(hid, data, offset + n * size, size),
 			       size) :
 			extract(hid, data, offset + n * size, size);
 		/* Ignore report if ErrorRollOver */
 		if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&
 		    value[n] >= min && value[n] <= max &&
 		    field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
 			goto exit;
 	}
 	for (n = 0; n < count; n++) {
 		if (HID_MAIN_ITEM_VARIABLE & field->flags) {
 			hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
 			continue;
 		}
 		if (field->value[n] >= min && field->value[n] <= max
 			&& field->usage[field->value[n] - min].hid
 			&& search(value, field->value[n], count))
 				hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);
 		if (value[n] >= min && value[n] <= max
 			&& field->usage[value[n] - min].hid
 			&& search(field->value, value[n], count))
 				hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
 	}
 	memcpy(field->value, value, count * sizeof(__s32));
 exit:
 	kfree(value);
 }
 /*
  * Output the field into the report.
  */
 static void hid_output_field(const struct hid_device *hid,
 			     struct hid_field *field, __u8 *data)
 {
 	unsigned count = field->report_count;
 	unsigned offset = field->report_offset;
 	unsigned size = field->report_size;
 	unsigned n;
 	for (n = 0; n < count; n++) {
 		if (field->logical_minimum < 0)	/* signed values */
 			implement(hid, data, offset + n * size, size,
 				  s32ton(field->value[n], size));
 		else				/* unsigned values */
 			implement(hid, data, offset + n * size, size,
 				  field->value[n]);
 	}
 }
 /*
  * Create a report.
  */
 void hid_output_report(struct hid_report *report, __u8 *data)
 {
 	unsigned n;
 	if (report->id > 0)
 		*data++ = report->id;
 	memset(data, 0, ((report->size - 1) >> 3) + 1);
 	for (n = 0; n < report->maxfield; n++)
 		hid_output_field(report->device, report->field[n], data);
 }
 EXPORT_SYMBOL_GPL(hid_output_report);
 /*
  * Set a field value. The report this field belongs to has to be
  * created and transferred to the device, to set this value in the
  * device.
  */
 int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 {
 	unsigned size = field->report_size;
 	hid_dump_input(field->report->device, field->usage + offset, value);
 	if (offset >= field->report_count) {
 		hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",
 				offset, field->report_count);
 		return -1;
 	}
 	if (field->logical_minimum < 0) {
 		if (value != snto32(s32ton(value, size), size)) {
 			hid_err(field->report->device, "value %d is out of range\n", value);
 			return -1;
 		}
 	}
 	field->value[offset] = value;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_set_field);
 static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
 		const u8 *data)
 {
 	struct hid_report *report;
 	unsigned int n = 0;	/* Normally report number is 0 */
 	/* Device uses numbered reports, data[0] is report number */
 	if (report_enum->numbered)
 		n = *data;
 	report = report_enum->report_id_hash[n];
 	if (report == NULL)
 		dbg_hid("undefined report_id %u received\n", n);
 	return report;
 }
 void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
 		int interrupt)
 {
 	struct hid_report_enum *report_enum = hid->report_enum + type;
 	struct hid_report *report;
 	unsigned int a;
 	int rsize, csize = size;
 	u8 *cdata = data;
 	report = hid_get_report(report_enum, data);
 	if (!report)
 		return;
 	if (report_enum->numbered) {
 		cdata++;
 		csize--;
 	}
 	rsize = ((report->size - 1) >> 3) + 1;
 	if (rsize > HID_MAX_BUFFER_SIZE)
 		rsize = HID_MAX_BUFFER_SIZE;
 	if (csize < rsize) {
 		dbg_hid("report %d is too short, (%d < %d)\n", report->id,
 				csize, rsize);
 		memset(cdata + csize, 0, rsize - csize);
 	}
 	if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
 		hid->hiddev_report_event(hid, report);
 	if (hid->claimed & HID_CLAIMED_HIDRAW)
 		hidraw_report_event(hid, data, size);
 	for (a = 0; a < report->maxfield; a++)
 		hid_input_field(hid, report->field[a], cdata, interrupt);
 	if (hid->claimed & HID_CLAIMED_INPUT)
 		hidinput_report_event(hid, report);
 }
 EXPORT_SYMBOL_GPL(hid_report_raw_event);
 /**
  * hid_input_report - report data from lower layer (usb, bt...)
  *
  * @hid: hid device
  * @type: HID report type (HID_*_REPORT)
  * @data: report contents
  * @size: size of data parameter
  * @interrupt: distinguish between interrupt and control transfers
  *
  * This is data entry for lower layers.
  */
 int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
 {
 	struct hid_report_enum *report_enum;
 	struct hid_driver *hdrv;
 	struct hid_report *report;
 	char *buf;
 	unsigned int i;
 	int ret = 0;
 	if (!hid)
 		return -ENODEV;
 	if (down_trylock(&hid->driver_lock))
 		return -EBUSY;
 	if (!hid->driver) {
 		ret = -ENODEV;
 		goto unlock;
 	}
 	report_enum = hid->report_enum + type;
 	hdrv = hid->driver;
 	if (!size) {
 		dbg_hid("empty report\n");
 		ret = -1;
 		goto unlock;
 	}
 	buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
 	if (!buf)
 		goto nomem;
 	/* dump the report */
 	snprintf(buf, HID_DEBUG_BUFSIZE - 1,
 			"\nreport (size %u) (%snumbered) = ", size, report_enum->numbered ? "" : "un");
 	hid_debug_event(hid, buf);
 	for (i = 0; i < size; i++) {
 		snprintf(buf, HID_DEBUG_BUFSIZE - 1,
 				" %02x", data[i]);
 		hid_debug_event(hid, buf);
 	}
 	hid_debug_event(hid, "\n");
 	kfree(buf);
 nomem:
 	report = hid_get_report(report_enum, data);
 	if (!report) {
 		ret = -1;
 		goto unlock;
 	}
 	if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
 		ret = hdrv->raw_event(hid, report, data, size);
 		if (ret != 0) {
 			ret = ret < 0 ? ret : 0;
 			goto unlock;
 		}
 	}
 	hid_report_raw_event(hid, type, data, size, interrupt);
 unlock:
 	up(&hid->driver_lock);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(hid_input_report);
 static bool hid_match_one_id(struct hid_device *hdev,
 		const struct hid_device_id *id)
 {
 	return id->bus == hdev->bus &&
 		(id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
 		(id->product == HID_ANY_ID || id->product == hdev->product);
 }
 const struct hid_device_id *hid_match_id(struct hid_device *hdev,
 		const struct hid_device_id *id)
 {
 	for (; id->bus; id++)
 		if (hid_match_one_id(hdev, id))
 			return id;
 	return NULL;
 }
 static const struct hid_device_id hid_hiddev_list[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
 	{ }
 };
 static bool hid_hiddev(struct hid_device *hdev)
 {
 	return !!hid_match_id(hdev, hid_hiddev_list);
 }
 static ssize_t
 read_report_descriptor(struct file *filp, struct kobject *kobj,
 		struct bin_attribute *attr,
 		char *buf, loff_t off, size_t count)
 {
 	struct device *dev = container_of(kobj, struct device, kobj);
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	if (off >= hdev->rsize)
 		return 0;
 	if (off + count > hdev->rsize)
 		count = hdev->rsize - off;
 	memcpy(buf, hdev->rdesc + off, count);
 	return count;
 }
 static struct bin_attribute dev_bin_attr_report_desc = {
 	.attr = { .name = "report_descriptor", .mode = 0444 },
 	.read = read_report_descriptor,
 	.size = HID_MAX_DESCRIPTOR_SIZE,
 };
 int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
 {
 	static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
 		"Joystick", "Gamepad", "Keyboard", "Keypad",
 		"Multi-Axis Controller"
 	};
 	const char *type, *bus;
 	char buf[64];
 	unsigned int i;
 	int len;
 	int ret;
 	if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
 		connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);
 	if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)
 		connect_mask |= HID_CONNECT_HIDINPUT_FORCE;
 	if (hdev->bus != BUS_USB)
 		connect_mask &= ~HID_CONNECT_HIDDEV;
 	if (hid_hiddev(hdev))
 		connect_mask |= HID_CONNECT_HIDDEV_FORCE;
 	if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
 				connect_mask & HID_CONNECT_HIDINPUT_FORCE))
 		hdev->claimed |= HID_CLAIMED_INPUT;
 	if (hdev->quirks & HID_QUIRK_MULTITOUCH) {
 		/* this device should be handled by hid-multitouch, skip it */
 		return -ENODEV;
 	}
 	if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
 			!hdev->hiddev_connect(hdev,
 				connect_mask & HID_CONNECT_HIDDEV_FORCE))
 		hdev->claimed |= HID_CLAIMED_HIDDEV;
 	if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
 		hdev->claimed |= HID_CLAIMED_HIDRAW;
 	if (!hdev->claimed) {
 		hid_err(hdev, "claimed by neither input, hiddev nor hidraw\n");
 		return -ENODEV;
 	}
 	if ((hdev->claimed & HID_CLAIMED_INPUT) &&
 			(connect_mask & HID_CONNECT_FF) && hdev->ff_init)
 		hdev->ff_init(hdev);
 	len = 0;
 	if (hdev->claimed & HID_CLAIMED_INPUT)
 		len += sprintf(buf + len, "input");
 	if (hdev->claimed & HID_CLAIMED_HIDDEV)
 		len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
 				hdev->minor);
 	if (hdev->claimed & HID_CLAIMED_HIDRAW)
 		len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
 				((struct hidraw *)hdev->hidraw)->minor);
 	type = "Device";
 	for (i = 0; i < hdev->maxcollection; i++) {
 		struct hid_collection *col = &hdev->collection[i];
 		if (col->type == HID_COLLECTION_APPLICATION &&
 		   (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
 		   (col->usage & 0xffff) < ARRAY_SIZE(types)) {
 			type = types[col->usage & 0xffff];
 			break;
 		}
 	}
 	switch (hdev->bus) {
 	case BUS_USB:
 		bus = "USB";
 		break;
 	case BUS_BLUETOOTH:
 		bus = "BLUETOOTH";
 		break;
 	default:
 		bus = "<UNKNOWN>";
 	}
 	ret = device_create_bin_file(&hdev->dev, &dev_bin_attr_report_desc);
 	if (ret)
 		hid_warn(hdev,
 			 "can't create sysfs report descriptor attribute err: %d\n", ret);
 	hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
 		 buf, bus, hdev->version >> 8, hdev->version & 0xff,
 		 type, hdev->name, hdev->phys);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_connect);
 void hid_disconnect(struct hid_device *hdev)
 {
 	device_remove_bin_file(&hdev->dev, &dev_bin_attr_report_desc);
 	if (hdev->claimed & HID_CLAIMED_INPUT)
 		hidinput_disconnect(hdev);
 	if (hdev->claimed & HID_CLAIMED_HIDDEV)
 		hdev->hiddev_disconnect(hdev);
 	if (hdev->claimed & HID_CLAIMED_HIDRAW)
 		hidraw_disconnect(hdev);
 }
 EXPORT_SYMBOL_GPL(hid_disconnect);
 /* a list of devices for which there is a specialized driver on HID bus */
 static const struct hid_device_id hid_have_special_driver[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M1968) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M2256) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR, USB_DEVICE_ID_ACTIONSTAR_1011) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, USB_DEVICE_ID_CVTOUCH_SCREEN) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2515) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_FRUCTEL, USB_DEVICE_ID_GAMETEL_MT_MODE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, USB_DEVICE_ID_GOODTOUCH_000f) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
  	{ HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM, USB_DEVICE_ID_IDEACOM_IDC6650) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ILITEK, USB_DEVICE_ID_ILITEK_MULTITOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MULTITOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },
 #if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },
 #endif
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, USB_DEVICE_ID_CRYSTALTOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT780) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT880) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_PCI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM, USB_DEVICE_ID_MTP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, USB_DEVICE_ID_MTP_STM) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX, USB_DEVICE_ID_MTP_SITRONIX) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb324) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_PID_0038) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XAT, USB_DEVICE_ID_XAT_CSR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },
 	{ }
 };
 struct hid_dynid {
 	struct list_head list;
 	struct hid_device_id id;
 };
 /**
  * store_new_id - add a new HID device ID to this driver and re-probe devices
  * @driver: target device driver
  * @buf: buffer for scanning device ID data
  * @count: input size
  *
  * Adds a new dynamic hid device ID to this driver,
  * and causes the driver to probe for all devices again.
  */
 static ssize_t store_new_id(struct device_driver *drv, const char *buf,
 		size_t count)
 {
 	struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
 	struct hid_dynid *dynid;
 	__u32 bus, vendor, product;
 	unsigned long driver_data = 0;
 	int ret;
 	ret = sscanf(buf, "%x %x %x %lx",
 			&bus, &vendor, &product, &driver_data);
 	if (ret < 3)
 		return -EINVAL;
 	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
 	if (!dynid)
 		return -ENOMEM;
 	dynid->id.bus = bus;
 	dynid->id.vendor = vendor;
 	dynid->id.product = product;
 	dynid->id.driver_data = driver_data;
 	spin_lock(&hdrv->dyn_lock);
 	list_add_tail(&dynid->list, &hdrv->dyn_list);
 	spin_unlock(&hdrv->dyn_lock);
 	ret = driver_attach(&hdrv->driver);
 	return ret ? : count;
 }
 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 static void hid_free_dynids(struct hid_driver *hdrv)
 {
 	struct hid_dynid *dynid, *n;
 	spin_lock(&hdrv->dyn_lock);
 	list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {
 		list_del(&dynid->list);
 		kfree(dynid);
 	}
 	spin_unlock(&hdrv->dyn_lock);
 }
 static const struct hid_device_id *hid_match_device(struct hid_device *hdev,
 		struct hid_driver *hdrv)
 {
 	struct hid_dynid *dynid;
 	spin_lock(&hdrv->dyn_lock);
 	list_for_each_entry(dynid, &hdrv->dyn_list, list) {
 		if (hid_match_one_id(hdev, &dynid->id)) {
 			spin_unlock(&hdrv->dyn_lock);
 			return &dynid->id;
 		}
 	}
 	spin_unlock(&hdrv->dyn_lock);
 	return hid_match_id(hdev, hdrv->id_table);
 }
 static int hid_bus_match(struct device *dev, struct device_driver *drv)
 {
 	struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	if ((hdev->quirks & HID_QUIRK_MULTITOUCH) &&
 		!strncmp(hdrv->name, "hid-multitouch", 14))
 		return 1;
 	if (!hid_match_device(hdev, hdrv))
 		return 0;
 	/* generic wants all that don't have specialized driver */
 	if (!strncmp(hdrv->name, "generic-", 8) && !hid_ignore_special_drivers)
 		return !hid_match_id(hdev, hid_have_special_driver);
 	return 1;
 }
 static int hid_device_probe(struct device *dev)
 {
 	struct hid_driver *hdrv = container_of(dev->driver,
 			struct hid_driver, driver);
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	const struct hid_device_id *id;
 	int ret = 0;
 	if (down_interruptible(&hdev->driver_lock))
 		return -EINTR;
 	if (!hdev->driver) {
 		id = hid_match_device(hdev, hdrv);
 		if (id == NULL) {
 			if (!((hdev->quirks & HID_QUIRK_MULTITOUCH) &&
 				!strncmp(hdrv->name, "hid-multitouch", 14))) {
 				ret = -ENODEV;
 				goto unlock;
 			}
 		}
 		hdev->driver = hdrv;
 		if (hdrv->probe) {
 			ret = hdrv->probe(hdev, id);
 		} else { /* default probe */
 			ret = hid_parse(hdev);
 			if (!ret)
 				ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 		}
 		if (ret)
 			hdev->driver = NULL;
 	}
 unlock:
 	up(&hdev->driver_lock);
 	return ret;
 }
 static int hid_device_remove(struct device *dev)
 {
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	struct hid_driver *hdrv;
 	if (down_interruptible(&hdev->driver_lock))
 		return -EINTR;
 	hdrv = hdev->driver;
 	if (hdrv) {
 		if (hdrv->remove)
 			hdrv->remove(hdev);
 		else /* default remove */
 			hid_hw_stop(hdev);
 		hdev->driver = NULL;
 	}
 	up(&hdev->driver_lock);
 	return 0;
 }
 static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",
 			hdev->bus, hdev->vendor, hdev->product))
 		return -ENOMEM;
 	if (add_uevent_var(env, "HID_NAME=%s", hdev->name))
 		return -ENOMEM;
 	if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))
 		return -ENOMEM;
 	if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
 		return -ENOMEM;
 	if (add_uevent_var(env, "MODALIAS=hid:b%04Xv%08Xp%08X",
 			hdev->bus, hdev->vendor, hdev->product))
 		return -ENOMEM;
 	return 0;
 }
 static struct bus_type hid_bus_type = {
 	.name		= "hid",
 	.match		= hid_bus_match,
 	.probe		= hid_device_probe,
 	.remove		= hid_device_remove,
 	.uevent		= hid_uevent,
 };
 /* a list of devices that shouldn't be handled by HID core at all */
 static const struct hid_device_id hid_ignore_list[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x0004) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x000a) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_KYE, 0x0058) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_BEATPAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0001) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0002) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0003) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },
 #if defined(CONFIG_MOUSE_SYNAPTICS_USB) || defined(CONFIG_MOUSE_SYNAPTICS_USB_MODULE)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_INT_TP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_CPAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_STICK) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_COMP_TP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WTP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DPAD) },
 #endif
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WACOM, HID_ANY_ID) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
 	{ }
 };
 /**
  * hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer
  *
  * There are composite devices for which we want to ignore only a certain
  * interface. This is a list of devices for which only the mouse interface will
  * be ignored. This allows a dedicated driver to take care of the interface.
  */
 static const struct hid_device_id hid_mouse_ignore_list[] = {
 	/* appletouch driver */
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
 	{ }
 };
 static bool hid_ignore(struct hid_device *hdev)
 {
 	switch (hdev->vendor) {
 	case USB_VENDOR_ID_CODEMERCS:
 		/* ignore all Code Mercenaries IOWarrior devices */
 		if (hdev->product >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&
 				hdev->product <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)
 			return true;
 		break;
 	case USB_VENDOR_ID_LOGITECH:
 		if (hdev->product >= USB_DEVICE_ID_LOGITECH_HARMONY_FIRST &&
 				hdev->product <= USB_DEVICE_ID_LOGITECH_HARMONY_LAST)
 			return true;
 		/*
 		 * The Keene FM transmitter USB device has the same USB ID as
 		 * the Logitech AudioHub Speaker, but it should ignore the hid.
 		 * Check if the name is that of the Keene device.
 		 * For reference: the name of the AudioHub is
 		 * "HOLTEK  AudioHub Speaker".
 		 */
 		if (hdev->product == USB_DEVICE_ID_LOGITECH_AUDIOHUB &&
 			!strcmp(hdev->name, "HOLTEK  B-LINK USB Audio  "))
 				return true;
 		break;
 	case USB_VENDOR_ID_SOUNDGRAPH:
 		if (hdev->product >= USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST &&
 		    hdev->product <= USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST)
 			return true;
 		break;
 	case USB_VENDOR_ID_HANWANG:
 		if (hdev->product >= USB_DEVICE_ID_HANWANG_TABLET_FIRST &&
 		    hdev->product <= USB_DEVICE_ID_HANWANG_TABLET_LAST)
 			return true;
 		break;
 	case USB_VENDOR_ID_JESS:
 		if (hdev->product == USB_DEVICE_ID_JESS_YUREX &&
 				hdev->type == HID_TYPE_USBNONE)
 			return true;
 	break;
 	}
 	if (hdev->type == HID_TYPE_USBMOUSE &&
 			hid_match_id(hdev, hid_mouse_ignore_list))
 		return true;
 	return !!hid_match_id(hdev, hid_ignore_list);
 }
 int hid_add_device(struct hid_device *hdev)
 {
 	static atomic_t id = ATOMIC_INIT(0);
 	int ret;
 	if (WARN_ON(hdev->status & HID_STAT_ADDED))
 		return -EBUSY;
 	/* we need to kill them here, otherwise they will stay allocated to
 	 * wait for coming driver */
 	if (!(hdev->quirks & HID_QUIRK_NO_IGNORE)
             && (hid_ignore(hdev) || (hdev->quirks & HID_QUIRK_IGNORE)))
 		return -ENODEV;
 	/* XXX hack, any other cleaner solution after the driver core
 	 * is converted to allow more than 20 bytes as the device name? */
 	dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
 		     hdev->vendor, hdev->product, atomic_inc_return(&id));
 	hid_debug_register(hdev, dev_name(&hdev->dev));
 	ret = device_add(&hdev->dev);
 	if (!ret)
 		hdev->status |= HID_STAT_ADDED;
 	else
 		hid_debug_unregister(hdev);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(hid_add_device);
 /**
  * hid_allocate_device - allocate new hid device descriptor
  *
  * Allocate and initialize hid device, so that hid_destroy_device might be
  * used to free it.
  *
  * New hid_device pointer is returned on success, otherwise ERR_PTR encoded
  * error value.
  */
 struct hid_device *hid_allocate_device(void)
 {
 	struct hid_device *hdev;
 	unsigned int i;
 	int ret = -ENOMEM;
 	hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
 	if (hdev == NULL)
 		return ERR_PTR(ret);
 	device_initialize(&hdev->dev);
 	hdev->dev.release = hid_device_release;
 	hdev->dev.bus = &hid_bus_type;
 	hdev->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
 			sizeof(struct hid_collection), GFP_KERNEL);
 	if (hdev->collection == NULL)
 		goto err;
 	hdev->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
 	for (i = 0; i < HID_REPORT_TYPES; i++)
 		INIT_LIST_HEAD(&hdev->report_enum[i].report_list);
 	init_waitqueue_head(&hdev->debug_wait);
 	INIT_LIST_HEAD(&hdev->debug_list);
 	sema_init(&hdev->driver_lock, 1);
 	return hdev;
 err:
 	put_device(&hdev->dev);
 	return ERR_PTR(ret);
 }
 EXPORT_SYMBOL_GPL(hid_allocate_device);
 static void hid_remove_device(struct hid_device *hdev)
 {
 	if (hdev->status & HID_STAT_ADDED) {
 		device_del(&hdev->dev);
 		hid_debug_unregister(hdev);
 		hdev->status &= ~HID_STAT_ADDED;
 	}
 }
 /**
  * hid_destroy_device - free previously allocated device
  *
  * @hdev: hid device
  *
  * If you allocate hid_device through hid_allocate_device, you should ever
  * free by this function.
  */
 void hid_destroy_device(struct hid_device *hdev)
 {
 	hid_remove_device(hdev);
 	put_device(&hdev->dev);
 }
 EXPORT_SYMBOL_GPL(hid_destroy_device);
 int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,
 		const char *mod_name)
 {
 	int ret;
 	hdrv->driver.name = hdrv->name;
 	hdrv->driver.bus = &hid_bus_type;
 	hdrv->driver.owner = owner;
 	hdrv->driver.mod_name = mod_name;
 	INIT_LIST_HEAD(&hdrv->dyn_list);
 	spin_lock_init(&hdrv->dyn_lock);
 	ret = driver_register(&hdrv->driver);
 	if (ret)
 		return ret;
 	ret = driver_create_file(&hdrv->driver, &driver_attr_new_id);
 	if (ret)
 		driver_unregister(&hdrv->driver);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(__hid_register_driver);
 void hid_unregister_driver(struct hid_driver *hdrv)
 {
 	driver_remove_file(&hdrv->driver, &driver_attr_new_id);
 	driver_unregister(&hdrv->driver);
 	hid_free_dynids(hdrv);
 }
 EXPORT_SYMBOL_GPL(hid_unregister_driver);
 int hid_check_keys_pressed(struct hid_device *hid)
 {
 	struct hid_input *hidinput;
 	int i;
 	if (!(hid->claimed & HID_CLAIMED_INPUT))
 		return 0;
 	list_for_each_entry(hidinput, &hid->inputs, list) {
 		for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)
 			if (hidinput->input->key[i])
 				return 1;
 	}
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_check_keys_pressed);
 static int __init hid_init(void)
 {
 	int ret;
 	if (hid_debug)
 		pr_warn("hid_debug is now used solely for parser and driver debugging.\n"
 			"debugfs is now used for inspecting the device (report descriptor, reports)\n");
 	ret = bus_register(&hid_bus_type);
 	if (ret) {
 		pr_err("can't register hid bus\n");
 		goto err;
 	}
 	ret = hidraw_init();
 	if (ret)
 		goto err_bus;
 	hid_debug_init();
 	return 0;
 err_bus:
 	bus_unregister(&hid_bus_type);
 err:
 	return ret;
 }
 static void __exit hid_exit(void)
 {
 	hid_debug_exit();
 	hidraw_exit();
 	bus_unregister(&hid_bus_type);
 }
 module_init(hid_init);
 module_exit(hid_exit);
 MODULE_AUTHOR("Andreas Gal");
 MODULE_AUTHOR("Vojtech Pavlik");
 MODULE_AUTHOR("Jiri Kosina");
 MODULE_LICENSE(DRIVER_LICENSE);

 /*
  *  USB HID quirks support for Linux
  *
  *  Copyright (c) 1999 Andreas Gal
  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  *  Copyright (c) 2006-2007 Jiri Kosina
  *  Copyright (c) 2007 Paul Walmsley
  */
 /*
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  */
 #ifndef HID_IDS_H_FILE
 #define HID_IDS_H_FILE
 #define USB_VENDOR_ID_3M		0x0596
 #define USB_DEVICE_ID_3M1968		0x0500
 #define USB_DEVICE_ID_3M2256		0x0502
 #define USB_DEVICE_ID_3M3266		0x0506
 #define USB_VENDOR_ID_A4TECH		0x09da
 #define USB_DEVICE_ID_A4TECH_WCP32PU	0x0006
 #define USB_DEVICE_ID_A4TECH_X5_005D	0x000a
 #define USB_DEVICE_ID_A4TECH_RP_649	0x001a
 #define USB_VENDOR_ID_AASHIMA		0x06d6
 #define USB_DEVICE_ID_AASHIMA_GAMEPAD	0x0025
 #define USB_DEVICE_ID_AASHIMA_PREDATOR	0x0026
 #define USB_VENDOR_ID_ACECAD		0x0460
 #define USB_DEVICE_ID_ACECAD_FLAIR	0x0004
 #define USB_DEVICE_ID_ACECAD_302	0x0008
 #define USB_VENDOR_ID_ACRUX		0x1a34
 #define USB_VENDOR_ID_ACTIONSTAR	0x2101
 #define USB_DEVICE_ID_ACTIONSTAR_1011	0x1011
 #define USB_VENDOR_ID_ADS_TECH		0x06e1
 #define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X	0xa155
 #define USB_VENDOR_ID_AFATECH		0x15a4
 #define USB_DEVICE_ID_AFATECH_AF9016	0x9016
 #define USB_VENDOR_ID_AIPTEK		0x08ca
 #define USB_DEVICE_ID_AIPTEK_01		0x0001
 #define USB_DEVICE_ID_AIPTEK_10		0x0010
 #define USB_DEVICE_ID_AIPTEK_20		0x0020
 #define USB_DEVICE_ID_AIPTEK_21		0x0021
 #define USB_DEVICE_ID_AIPTEK_22		0x0022
 #define USB_DEVICE_ID_AIPTEK_23		0x0023
 #define USB_DEVICE_ID_AIPTEK_24		0x0024
 #define USB_VENDOR_ID_AIRCABLE		0x16CA
 #define USB_DEVICE_ID_AIRCABLE1		0x1502
 #define USB_VENDOR_ID_AIREN		0x1a2c
 #define USB_DEVICE_ID_AIREN_SLIMPLUS	0x0002
 #define USB_VENDOR_ID_ALCOR		0x058f
 #define USB_DEVICE_ID_ALCOR_USBRS232	0x9720
 #define USB_VENDOR_ID_ALPS		0x0433
 #define USB_DEVICE_ID_IBM_GAMEPAD	0x1101
 #define USB_VENDOR_ID_APPLE		0x05ac
 #define USB_DEVICE_ID_APPLE_MIGHTYMOUSE	0x0304
 #define USB_DEVICE_ID_APPLE_MAGICMOUSE	0x030d
 #define USB_DEVICE_ID_APPLE_MAGICTRACKPAD	0x030e
 #define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI	0x020e
 #define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO	0x020f
 #define USB_DEVICE_ID_APPLE_GEYSER_ANSI	0x0214
 #define USB_DEVICE_ID_APPLE_GEYSER_ISO	0x0215
 #define USB_DEVICE_ID_APPLE_GEYSER_JIS	0x0216
 #define USB_DEVICE_ID_APPLE_GEYSER3_ANSI	0x0217
 #define USB_DEVICE_ID_APPLE_GEYSER3_ISO	0x0218
 #define USB_DEVICE_ID_APPLE_GEYSER3_JIS	0x0219
 #define USB_DEVICE_ID_APPLE_GEYSER4_ANSI	0x021a
 #define USB_DEVICE_ID_APPLE_GEYSER4_ISO	0x021b
 #define USB_DEVICE_ID_APPLE_GEYSER4_JIS	0x021c
 #define USB_DEVICE_ID_APPLE_ALU_MINI_ANSI	0x021d
 #define USB_DEVICE_ID_APPLE_ALU_MINI_ISO	0x021e
 #define USB_DEVICE_ID_APPLE_ALU_MINI_JIS	0x021f
 #define USB_DEVICE_ID_APPLE_ALU_ANSI	0x0220
 #define USB_DEVICE_ID_APPLE_ALU_ISO	0x0221
 #define USB_DEVICE_ID_APPLE_ALU_JIS	0x0222
 #define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI	0x0223
 #define USB_DEVICE_ID_APPLE_WELLSPRING_ISO	0x0224
 #define USB_DEVICE_ID_APPLE_WELLSPRING_JIS	0x0225
 #define USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI	0x0229
 #define USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO	0x022a
 #define USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS	0x022b
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI	0x022c
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO	0x022d
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS	0x022e
 #define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI	0x0230
 #define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO	0x0231
 #define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS	0x0232
 #define USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI	0x0236
 #define USB_DEVICE_ID_APPLE_WELLSPRING3_ISO	0x0237
 #define USB_DEVICE_ID_APPLE_WELLSPRING3_JIS	0x0238
 #define USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI	0x023f
 #define USB_DEVICE_ID_APPLE_WELLSPRING4_ISO	0x0240
 #define USB_DEVICE_ID_APPLE_WELLSPRING4_JIS	0x0241
 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI	0x0242
 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO	0x0243
 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS	0x0244
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI	0x0245
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO	0x0246
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS	0x0247
 #define USB_DEVICE_ID_APPLE_ALU_REVB_ANSI	0x024f
 #define USB_DEVICE_ID_APPLE_ALU_REVB_ISO	0x0250
 #define USB_DEVICE_ID_APPLE_ALU_REVB_JIS	0x0251
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI	0x0252
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO	0x0253
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS	0x0254
 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI	0x0249
 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO	0x024a
 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS	0x024b
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI	0x024c
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ISO	0x024d
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_JIS	0x024e
 #define USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI	0x0262
 #define USB_DEVICE_ID_APPLE_WELLSPRING7_ISO	0x0263
 #define USB_DEVICE_ID_APPLE_WELLSPRING7_JIS	0x0264
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI  0x0239
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO   0x023a
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS   0x023b
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI  0x0255
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO   0x0256
 #define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY	0x030a
 #define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY	0x030b
 #define USB_DEVICE_ID_APPLE_ATV_IRCONTROL	0x8241
 #define USB_DEVICE_ID_APPLE_IRCONTROL4	0x8242
 #define USB_VENDOR_ID_ASUS		0x0486
 #define USB_DEVICE_ID_ASUS_T91MT	0x0185
 #define USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO	0x0186
 #define USB_VENDOR_ID_ASUSTEK		0x0b05
 #define USB_DEVICE_ID_ASUSTEK_LCM	0x1726
 #define USB_DEVICE_ID_ASUSTEK_LCM2	0x175b
 #define USB_VENDOR_ID_ATEN		0x0557
 #define USB_DEVICE_ID_ATEN_UC100KM	0x2004
 #define USB_DEVICE_ID_ATEN_CS124U	0x2202
 #define USB_DEVICE_ID_ATEN_2PORTKVM	0x2204
 #define USB_DEVICE_ID_ATEN_4PORTKVM	0x2205
 #define USB_DEVICE_ID_ATEN_4PORTKVMC	0x2208
 #define USB_VENDOR_ID_ATMEL		0x03eb
 #define USB_DEVICE_ID_ATMEL_MULTITOUCH	0x211c
 #define USB_DEVICE_ID_ATMEL_MXT_DIGITIZER	0x2118
 #define USB_VENDOR_ID_AVERMEDIA		0x07ca
 #define USB_DEVICE_ID_AVER_FM_MR800	0xb800
 #define USB_VENDOR_ID_BELKIN		0x050d
 #define USB_DEVICE_ID_FLIP_KVM		0x3201
 #define USB_VENDOR_ID_BERKSHIRE		0x0c98
 #define USB_DEVICE_ID_BERKSHIRE_PCWD	0x1140
 #define USB_VENDOR_ID_BTC		0x046e
 #define USB_DEVICE_ID_BTC_EMPREX_REMOTE	0x5578
 #define USB_DEVICE_ID_BTC_EMPREX_REMOTE_2	0x5577
 #define USB_VENDOR_ID_CANDO		0x2087
 #define USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH 0x0703
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH	0x0a01
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1 0x0a02
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6 0x0b03
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6 0x0f01
 #define USB_VENDOR_ID_CH		0x068e
 #define USB_DEVICE_ID_CH_PRO_THROTTLE	0x00f1
 #define USB_DEVICE_ID_CH_PRO_PEDALS	0x00f2
 #define USB_DEVICE_ID_CH_FIGHTERSTICK	0x00f3
 #define USB_DEVICE_ID_CH_COMBATSTICK	0x00f4
 #define USB_DEVICE_ID_CH_FLIGHT_SIM_ECLIPSE_YOKE       0x0051
 #define USB_DEVICE_ID_CH_FLIGHT_SIM_YOKE	0x00ff
 #define USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK	0x00d3
 #define USB_DEVICE_ID_CH_AXIS_295	0x001c
 #define USB_VENDOR_ID_CHERRY		0x046a
 #define USB_DEVICE_ID_CHERRY_CYMOTION	0x0023
 #define USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR	0x0027
 #define USB_VENDOR_ID_CHIC		0x05fe
 #define USB_DEVICE_ID_CHIC_GAMEPAD	0x0014
 #define USB_VENDOR_ID_CHICONY		0x04f2
 #define USB_DEVICE_ID_CHICONY_TACTICAL_PAD	0x0418
 #define USB_DEVICE_ID_CHICONY_MULTI_TOUCH	0xb19d
 #define USB_DEVICE_ID_CHICONY_WIRELESS	0x0618
 #define USB_DEVICE_ID_CHICONY_WIRELESS2	0x1123
 #define USB_VENDOR_ID_CHUNGHWAT		0x2247
 #define USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH	0x0001
 #define USB_VENDOR_ID_CIDC		0x1677
 #define USB_VENDOR_ID_CMEDIA		0x0d8c
 #define USB_DEVICE_ID_CM109		0x000e
 #define USB_VENDOR_ID_CODEMERCS		0x07c0
 #define USB_DEVICE_ID_CODEMERCS_IOW_FIRST	0x1500
 #define USB_DEVICE_ID_CODEMERCS_IOW_LAST	0x15ff
 #define USB_VENDOR_ID_CREATIVELABS	0x041e
 #define USB_DEVICE_ID_PRODIKEYS_PCMIDI	0x2801
 #define USB_VENDOR_ID_CVTOUCH		0x1ff7
 #define USB_DEVICE_ID_CVTOUCH_SCREEN	0x0013
 #define USB_VENDOR_ID_CYGNAL		0x10c4
 #define USB_DEVICE_ID_CYGNAL_RADIO_SI470X	0x818a
 #define USB_VENDOR_ID_CYPRESS		0x04b4
 #define USB_DEVICE_ID_CYPRESS_MOUSE	0x0001
 #define USB_DEVICE_ID_CYPRESS_HIDCOM	0x5500
 #define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE	0x7417
 #define USB_DEVICE_ID_CYPRESS_BARCODE_1	0xde61
 #define USB_DEVICE_ID_CYPRESS_BARCODE_2	0xde64
 #define USB_DEVICE_ID_CYPRESS_BARCODE_3	0xbca1
 #define USB_DEVICE_ID_CYPRESS_TRUETOUCH	0xc001
 #define USB_VENDOR_ID_DEALEXTREAME	0x10c5
 #define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701	0x819a
 #define USB_VENDOR_ID_DELORME		0x1163
 #define USB_DEVICE_ID_DELORME_EARTHMATE	0x0100
 #define USB_DEVICE_ID_DELORME_EM_LT20	0x0200
 #define USB_VENDOR_ID_DMI		0x0c0b
 #define USB_DEVICE_ID_DMI_ENC		0x5fab
 #define USB_VENDOR_ID_DRAGONRISE	0x0079
 #define USB_VENDOR_ID_DWAV		0x0eef
 #define USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER	0x0001
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D	0x480d
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E	0x480e
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207	0x7207
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C	0x720c
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224	0x7224
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A	0x722A
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E	0x725e
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262	0x7262
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B	0x726b
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA	0x72aa
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1	0x72a1
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA	0x72fa
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302	0x7302
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349	0x7349
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001	0xa001
 #define USB_VENDOR_ID_ELECOM		0x056e
 #define USB_DEVICE_ID_ELECOM_BM084	0x0061
 #define USB_VENDOR_ID_DREAM_CHEEKY	0x1d34
 #define USB_VENDOR_ID_ELO		0x04E7
 #define USB_DEVICE_ID_ELO_TS2515	0x0022
 #define USB_DEVICE_ID_ELO_TS2700	0x0020
 #define USB_VENDOR_ID_EMS		0x2006
 #define USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II 0x0118
 #define USB_VENDOR_ID_ESSENTIAL_REALITY	0x0d7f
 #define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
 #define USB_VENDOR_ID_ETT		0x0664
 #define USB_DEVICE_ID_TC5UH		0x0309
 #define USB_DEVICE_ID_TC4UM		0x0306
 #define USB_VENDOR_ID_ETURBOTOUCH	0x22b9
 #define USB_DEVICE_ID_ETURBOTOUCH	0x0006
 #define USB_VENDOR_ID_EZKEY		0x0518
 #define USB_DEVICE_ID_BTC_8193		0x0002
 #define USB_VENDOR_ID_FRUCTEL	0x25B6
 #define USB_DEVICE_ID_GAMETEL_MT_MODE	0x0002
 #define USB_VENDOR_ID_GAMERON		0x0810
 #define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR	0x0001
 #define USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR	0x0002
 #define USB_VENDOR_ID_GENERAL_TOUCH	0x0dfc
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS 0x0003
 #define USB_VENDOR_ID_GLAB		0x06c2
 #define USB_DEVICE_ID_4_PHIDGETSERVO_30	0x0038
 #define USB_DEVICE_ID_1_PHIDGETSERVO_30	0x0039
 #define USB_DEVICE_ID_0_0_4_IF_KIT	0x0040
 #define USB_DEVICE_ID_0_16_16_IF_KIT	0x0044
 #define USB_DEVICE_ID_8_8_8_IF_KIT	0x0045
 #define USB_DEVICE_ID_0_8_7_IF_KIT	0x0051
 #define USB_DEVICE_ID_0_8_8_IF_KIT	0x0053
 #define USB_DEVICE_ID_PHIDGET_MOTORCONTROL	0x0058
 #define USB_VENDOR_ID_GOODTOUCH		0x1aad
 #define USB_DEVICE_ID_GOODTOUCH_000f	0x000f
 #define USB_VENDOR_ID_GOTOP		0x08f2
 #define USB_DEVICE_ID_SUPER_Q2		0x007f
 #define USB_DEVICE_ID_GOGOPEN		0x00ce
 #define USB_DEVICE_ID_PENPOWER		0x00f4
 #define USB_VENDOR_ID_GREENASIA		0x0e8f
 #define USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD	0x3013
 #define USB_VENDOR_ID_GRETAGMACBETH	0x0971
 #define USB_DEVICE_ID_GRETAGMACBETH_HUEY	0x2005
 #define USB_VENDOR_ID_GRIFFIN		0x077d
 #define USB_DEVICE_ID_POWERMATE		0x0410
 #define USB_DEVICE_ID_SOUNDKNOB		0x04AA
 #define USB_VENDOR_ID_GTCO		0x078c
 #define USB_DEVICE_ID_GTCO_90		0x0090
 #define USB_DEVICE_ID_GTCO_100		0x0100
 #define USB_DEVICE_ID_GTCO_101		0x0101
 #define USB_DEVICE_ID_GTCO_103		0x0103
 #define USB_DEVICE_ID_GTCO_104		0x0104
 #define USB_DEVICE_ID_GTCO_105		0x0105
 #define USB_DEVICE_ID_GTCO_106		0x0106
 #define USB_DEVICE_ID_GTCO_107		0x0107
 #define USB_DEVICE_ID_GTCO_108		0x0108
 #define USB_DEVICE_ID_GTCO_200		0x0200
 #define USB_DEVICE_ID_GTCO_201		0x0201
 #define USB_DEVICE_ID_GTCO_202		0x0202
 #define USB_DEVICE_ID_GTCO_203		0x0203
 #define USB_DEVICE_ID_GTCO_204		0x0204
 #define USB_DEVICE_ID_GTCO_205		0x0205
 #define USB_DEVICE_ID_GTCO_206		0x0206
 #define USB_DEVICE_ID_GTCO_207		0x0207
 #define USB_DEVICE_ID_GTCO_300		0x0300
 #define USB_DEVICE_ID_GTCO_301		0x0301
 #define USB_DEVICE_ID_GTCO_302		0x0302
 #define USB_DEVICE_ID_GTCO_303		0x0303
 #define USB_DEVICE_ID_GTCO_304		0x0304
 #define USB_DEVICE_ID_GTCO_305		0x0305
 #define USB_DEVICE_ID_GTCO_306		0x0306
 #define USB_DEVICE_ID_GTCO_307		0x0307
 #define USB_DEVICE_ID_GTCO_308		0x0308
 #define USB_DEVICE_ID_GTCO_309		0x0309
 #define USB_DEVICE_ID_GTCO_400		0x0400
 #define USB_DEVICE_ID_GTCO_401		0x0401
 #define USB_DEVICE_ID_GTCO_402		0x0402
 #define USB_DEVICE_ID_GTCO_403		0x0403
 #define USB_DEVICE_ID_GTCO_404		0x0404
 #define USB_DEVICE_ID_GTCO_405		0x0405
 #define USB_DEVICE_ID_GTCO_500		0x0500
 #define USB_DEVICE_ID_GTCO_501		0x0501
 #define USB_DEVICE_ID_GTCO_502		0x0502
 #define USB_DEVICE_ID_GTCO_503		0x0503
 #define USB_DEVICE_ID_GTCO_504		0x0504
 #define USB_DEVICE_ID_GTCO_1000		0x1000
 #define USB_DEVICE_ID_GTCO_1001		0x1001
 #define USB_DEVICE_ID_GTCO_1002		0x1002
 #define USB_DEVICE_ID_GTCO_1003		0x1003
 #define USB_DEVICE_ID_GTCO_1004		0x1004
 #define USB_DEVICE_ID_GTCO_1005		0x1005
 #define USB_DEVICE_ID_GTCO_1006		0x1006
 #define USB_DEVICE_ID_GTCO_1007		0x1007
 #define USB_VENDOR_ID_GYRATION		0x0c16
 #define USB_DEVICE_ID_GYRATION_REMOTE	0x0002
 #define USB_DEVICE_ID_GYRATION_REMOTE_2 0x0003
 #define USB_DEVICE_ID_GYRATION_REMOTE_3 0x0008
 #define USB_VENDOR_ID_HANWANG		0x0b57
 #define USB_DEVICE_ID_HANWANG_TABLET_FIRST	0x5000
 #define USB_DEVICE_ID_HANWANG_TABLET_LAST	0x8fff
 #define USB_VENDOR_ID_HANVON		0x20b3
 #define USB_DEVICE_ID_HANVON_MULTITOUCH	0x0a18
 #define USB_VENDOR_ID_HANVON_ALT	0x22ed
 #define USB_DEVICE_ID_HANVON_ALT_MULTITOUCH	0x1010
 #define USB_VENDOR_ID_HAPP		0x078b
 #define USB_DEVICE_ID_UGCI_DRIVING	0x0010
 #define USB_DEVICE_ID_UGCI_FLYING	0x0020
 #define USB_DEVICE_ID_UGCI_FIGHTING	0x0030
 #define USB_VENDOR_ID_IDEACOM		0x1cb6
 #define USB_DEVICE_ID_IDEACOM_IDC6650	0x6650
 #define USB_DEVICE_ID_IDEACOM_IDC6651	0x6651
 #define USB_VENDOR_ID_ILITEK		0x222a
 #define USB_DEVICE_ID_ILITEK_MULTITOUCH	0x0001
 #define USB_VENDOR_ID_HOLTEK		0x1241
 #define USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP	0x5015
 #define USB_VENDOR_ID_IMATION		0x0718
 #define USB_DEVICE_ID_DISC_STAKKA	0xd000
 #define USB_VENDOR_ID_IRTOUCHSYSTEMS	0x6615
 #define USB_DEVICE_ID_IRTOUCH_INFRARED_USB	0x0070
 #define USB_VENDOR_ID_JESS		0x0c45
 #define USB_DEVICE_ID_JESS_YUREX	0x1010
 #define USB_VENDOR_ID_KBGEAR		0x084e
 #define USB_DEVICE_ID_KBGEAR_JAMSTUDIO	0x1001
 #define USB_VENDOR_ID_KENSINGTON	0x047d
 #define USB_DEVICE_ID_KS_SLIMBLADE	0x2041
 #define USB_VENDOR_ID_KWORLD		0x1b80
 #define USB_DEVICE_ID_KWORLD_RADIO_FM700	0xd700
 #define USB_VENDOR_ID_KEYTOUCH		0x0926
 #define USB_DEVICE_ID_KEYTOUCH_IEC	0x3333
 #define USB_VENDOR_ID_KYE		0x0458
 #define USB_DEVICE_ID_KYE_ERGO_525V	0x0087
 #define USB_DEVICE_ID_KYE_GPEN_560	0x5003
 #define USB_DEVICE_ID_KYE_EASYPEN_I405X	0x5010
 #define USB_DEVICE_ID_KYE_MOUSEPEN_I608X	0x5011
 #define USB_DEVICE_ID_KYE_EASYPEN_M610X	0x5013
 #define USB_VENDOR_ID_LABTEC		0x1020
 #define USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD	0x0006
 #define USB_VENDOR_ID_LCPOWER		0x1241
 #define USB_DEVICE_ID_LCPOWER_LC1000	0xf767
 #define USB_VENDOR_ID_LD		0x0f11
 #define USB_DEVICE_ID_LD_CASSY		0x1000
 #define USB_DEVICE_ID_LD_CASSY2		0x1001
 #define USB_DEVICE_ID_LD_POCKETCASSY	0x1010
 #define USB_DEVICE_ID_LD_POCKETCASSY2	0x1011
 #define USB_DEVICE_ID_LD_MOBILECASSY	0x1020
 #define USB_DEVICE_ID_LD_MOBILECASSY2	0x1021
 #define USB_DEVICE_ID_LD_MICROCASSYVOLTAGE	0x1031
 #define USB_DEVICE_ID_LD_MICROCASSYCURRENT	0x1032
 #define USB_DEVICE_ID_LD_MICROCASSYTIME		0x1033
 #define USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE	0x1035
 #define USB_DEVICE_ID_LD_MICROCASSYPH		0x1038
 #define USB_DEVICE_ID_LD_JWM		0x1080
 #define USB_DEVICE_ID_LD_DMMP		0x1081
 #define USB_DEVICE_ID_LD_UMIP		0x1090
 #define USB_DEVICE_ID_LD_UMIC		0x10A0
 #define USB_DEVICE_ID_LD_UMIB		0x10B0
 #define USB_DEVICE_ID_LD_XRAY		0x1100
 #define USB_DEVICE_ID_LD_XRAY2		0x1101
 #define USB_DEVICE_ID_LD_XRAYCT		0x1110
 #define USB_DEVICE_ID_LD_VIDEOCOM	0x1200
 #define USB_DEVICE_ID_LD_MOTOR		0x1210
 #define USB_DEVICE_ID_LD_COM3LAB	0x2000
 #define USB_DEVICE_ID_LD_TELEPORT	0x2010
 #define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020
 #define USB_DEVICE_ID_LD_POWERCONTROL	0x2030
 #define USB_DEVICE_ID_LD_MACHINETEST	0x2040
 #define USB_DEVICE_ID_LD_MOSTANALYSER	0x2050
 #define USB_DEVICE_ID_LD_MOSTANALYSER2	0x2051
 #define USB_DEVICE_ID_LD_ABSESP		0x2060
 #define USB_DEVICE_ID_LD_AUTODATABUS	0x2070
 #define USB_DEVICE_ID_LD_MCT		0x2080
 #define USB_DEVICE_ID_LD_HYBRID		0x2090
 #define USB_DEVICE_ID_LD_HEATCONTROL	0x20A0
 #define USB_VENDOR_ID_LG		0x1fd2
 #define USB_DEVICE_ID_LG_MULTITOUCH	0x0064
 #define USB_VENDOR_ID_LOGITECH		0x046d
 #define USB_DEVICE_ID_LOGITECH_AUDIOHUB 0x0a0e
 #define USB_DEVICE_ID_LOGITECH_RECEIVER	0xc101
 #define USB_DEVICE_ID_LOGITECH_HARMONY_FIRST  0xc110
 #define USB_DEVICE_ID_LOGITECH_HARMONY_LAST 0xc14f
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD	0xc20a
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD	0xc211
 #define USB_DEVICE_ID_LOGITECH_EXTREME_3D	0xc215
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2	0xc218
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2	0xc219
 #define USB_DEVICE_ID_LOGITECH_WINGMAN_F3D	0xc283
 #define USB_DEVICE_ID_LOGITECH_FORCE3D_PRO	0xc286
 #define USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940	0xc287
 #define USB_DEVICE_ID_LOGITECH_WHEEL	0xc294
 #define USB_DEVICE_ID_LOGITECH_WINGMAN_FFG	0xc293
 #define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL	0xc295
 #define USB_DEVICE_ID_LOGITECH_DFP_WHEEL	0xc298
 #define USB_DEVICE_ID_LOGITECH_G25_WHEEL	0xc299
 #define USB_DEVICE_ID_LOGITECH_DFGT_WHEEL	0xc29a
 #define USB_DEVICE_ID_LOGITECH_G27_WHEEL	0xc29b
 #define USB_DEVICE_ID_LOGITECH_WII_WHEEL	0xc29c
 #define USB_DEVICE_ID_LOGITECH_ELITE_KBD	0xc30a
 #define USB_DEVICE_ID_S510_RECEIVER	0xc50c
 #define USB_DEVICE_ID_S510_RECEIVER_2	0xc517
 #define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500	0xc512
 #define USB_DEVICE_ID_MX3000_RECEIVER	0xc513
 #define USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER	0xc52b
 #define USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2	0xc532
 #define USB_DEVICE_ID_SPACETRAVELLER	0xc623
 #define USB_DEVICE_ID_SPACENAVIGATOR	0xc626
 #define USB_DEVICE_ID_DINOVO_DESKTOP	0xc704
 #define USB_DEVICE_ID_DINOVO_EDGE	0xc714
 #define USB_DEVICE_ID_DINOVO_MINI	0xc71f
 #define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2	0xca03
 #define USB_VENDOR_ID_LUMIO		0x202e
 #define USB_DEVICE_ID_CRYSTALTOUCH	0x0006
 #define USB_DEVICE_ID_CRYSTALTOUCH_DUAL	0x0007
+#define USB_VENDOR_ID_MADCATZ		0x0738
+#define USB_DEVICE_ID_MADCATZ_BEATPAD	0x4540
 #define USB_VENDOR_ID_MCC		0x09db
 #define USB_DEVICE_ID_MCC_PMD1024LS	0x0076
 #define USB_DEVICE_ID_MCC_PMD1208LS	0x007a
 #define USB_VENDOR_ID_MGE		0x0463
 #define USB_DEVICE_ID_MGE_UPS		0xffff
 #define USB_DEVICE_ID_MGE_UPS1		0x0001
 #define USB_VENDOR_ID_MICROCHIP		0x04d8
 #define USB_DEVICE_ID_PICKIT1		0x0032
 #define USB_DEVICE_ID_PICKIT2		0x0033
 #define USB_DEVICE_ID_PICOLCD		0xc002
 #define USB_DEVICE_ID_PICOLCD_BOOTLOADER	0xf002
 #define USB_VENDOR_ID_MICROSOFT		0x045e
 #define USB_DEVICE_ID_SIDEWINDER_GV	0x003b
 #define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
 #define USB_DEVICE_ID_MS_NE4K		0x00db
 #define USB_DEVICE_ID_MS_LK6K		0x00f9
 #define USB_DEVICE_ID_MS_PRESENTER_8K_BT	0x0701
 #define USB_DEVICE_ID_MS_PRESENTER_8K_USB	0x0713
 #define USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K	0x0730
 #define USB_DEVICE_ID_MS_COMFORT_MOUSE_4500	0x076c
 #define USB_VENDOR_ID_MOJO		0x8282
 #define USB_DEVICE_ID_RETRO_ADAPTER	0x3201
 #define USB_VENDOR_ID_MONTEREY		0x0566
 #define USB_DEVICE_ID_GENIUS_KB29E	0x3004
 #define USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR 0x0400
 #define USB_DEVICE_ID_N_S_HARMONY	0xc359
 #define USB_VENDOR_ID_NATSU		0x08b7
 #define USB_DEVICE_ID_NATSU_GAMEPAD	0x0001
 #define USB_VENDOR_ID_NCR		0x0404
 #define USB_DEVICE_ID_NCR_FIRST		0x0300
 #define USB_DEVICE_ID_NCR_LAST		0x03ff
 #define USB_VENDOR_ID_NEC		0x073e
 #define USB_DEVICE_ID_NEC_USB_GAME_PAD	0x0301
 #define USB_VENDOR_ID_NEXTWINDOW	0x1926
 #define USB_DEVICE_ID_NEXTWINDOW_TOUCHSCREEN	0x0003
 #define USB_VENDOR_ID_NINTENDO		0x057e
 #define USB_DEVICE_ID_NINTENDO_WIIMOTE	0x0306
 #define USB_VENDOR_ID_NTRIG		0x1b96
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN   0x0001
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1   0x0003
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2   0x0004
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3   0x0005
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4   0x0006
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5   0x0007
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6   0x0008
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7   0x0009
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8   0x000A
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9   0x000B
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10   0x000C
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11   0x000D
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12   0x000E
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13   0x000F
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14   0x0010
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15   0x0011
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16   0x0012
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17   0x0013
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18   0x0014
 #define USB_VENDOR_ID_ONTRAK		0x0a07
 #define USB_DEVICE_ID_ONTRAK_ADU100	0x0064
 #define USB_VENDOR_ID_ORTEK		0x05a4
 #define USB_DEVICE_ID_ORTEK_PKB1700	0x1700
 #define USB_DEVICE_ID_ORTEK_WKB2000	0x2000
 #define USB_VENDOR_ID_PANASONIC		0x04da
 #define USB_DEVICE_ID_PANABOARD_UBT780	0x1044
 #define USB_DEVICE_ID_PANABOARD_UBT880	0x104d
 #define USB_VENDOR_ID_PANJIT		0x134c
 #define USB_VENDOR_ID_PANTHERLORD	0x0810
 #define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK	0x0001
 #define USB_VENDOR_ID_PENMOUNT		0x14e1
 #define USB_DEVICE_ID_PENMOUNT_PCI	0x3500
 #define USB_VENDOR_ID_PETALYNX		0x18b1
 #define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE	0x0037
 #define USB_VENDOR_ID_PHILIPS		0x0471
 #define USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE 0x0617
 #define USB_VENDOR_ID_PI_ENGINEERING	0x05f3
 #define USB_DEVICE_ID_PI_ENGINEERING_VEC_USB_FOOTPEDAL	0xff
 #define USB_VENDOR_ID_PIXART				0x093a
 #define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN	0x8001
 #define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1	0x8002
 #define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2	0x8003
 #define USB_VENDOR_ID_PLAYDOTCOM	0x0b43
 #define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII	0x0003
 #define USB_VENDOR_ID_POWERCOM		0x0d9f
 #define USB_DEVICE_ID_POWERCOM_UPS	0x0002
 #define USB_VENDOR_ID_PRODIGE		0x05af
 #define USB_DEVICE_ID_PRODIGE_CORDLESS	0x3062
 #define USB_VENDOR_ID_QUANTA		0x0408
 #define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH		0x3000
 #define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001		0x3001
 #define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008		0x3008
 #define USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN	0x3001
 #define USB_VENDOR_ID_ROCCAT		0x1e7d
 #define USB_DEVICE_ID_ROCCAT_ARVO	0x30d4
 #define USB_DEVICE_ID_ROCCAT_ISKU	0x319c
 #define USB_DEVICE_ID_ROCCAT_KONE	0x2ced
 #define USB_DEVICE_ID_ROCCAT_KONEPLUS	0x2d51
 #define USB_DEVICE_ID_ROCCAT_KOVAPLUS	0x2d50
 #define USB_DEVICE_ID_ROCCAT_PYRA_WIRED	0x2c24
 #define USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS	0x2cf6
 #define USB_VENDOR_ID_SAITEK		0x06a3
 #define USB_DEVICE_ID_SAITEK_RUMBLEPAD	0xff17
 #define USB_DEVICE_ID_SAITEK_PS1000	0x0621
 #define USB_VENDOR_ID_SAMSUNG		0x0419
 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE	0x0001
 #define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE	0x0600
 #define USB_VENDOR_ID_SIGMA_MICRO	0x1c4f
 #define USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD	0x0002
 #define USB_VENDOR_ID_SKYCABLE			0x1223
 #define	USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER	0x3F07
 #define USB_VENDOR_ID_SONY			0x054c
 #define USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE	0x024b
 #define USB_DEVICE_ID_SONY_PS3_CONTROLLER	0x0268
 #define USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER	0x042f
 #define USB_VENDOR_ID_SOUNDGRAPH	0x15c2
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST	0x0034
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST	0x0046
 #define USB_VENDOR_ID_STANTUM		0x1f87
 #define USB_DEVICE_ID_MTP		0x0002
 #define USB_VENDOR_ID_STANTUM_STM		0x0483
 #define USB_DEVICE_ID_MTP_STM		0x3261
 #define USB_VENDOR_ID_STANTUM_SITRONIX		0x1403
 #define USB_DEVICE_ID_MTP_SITRONIX		0x5001
 #define USB_VENDOR_ID_SUN		0x0430
 #define USB_DEVICE_ID_RARITAN_KVM_DONGLE	0xcdab
 #define USB_VENDOR_ID_SUNPLUS		0x04fc
 #define USB_DEVICE_ID_SUNPLUS_WDESKTOP	0x05d8
 #define USB_VENDOR_ID_SYMBOL		0x05e0
 #define USB_DEVICE_ID_SYMBOL_SCANNER_1	0x0800
 #define USB_DEVICE_ID_SYMBOL_SCANNER_2	0x1300
 #define USB_VENDOR_ID_SYNAPTICS		0x06cb
 #define USB_DEVICE_ID_SYNAPTICS_TP	0x0001
 #define USB_DEVICE_ID_SYNAPTICS_INT_TP	0x0002
 #define USB_DEVICE_ID_SYNAPTICS_CPAD	0x0003
 #define USB_DEVICE_ID_SYNAPTICS_TS	0x0006
 #define USB_DEVICE_ID_SYNAPTICS_STICK	0x0007
 #define USB_DEVICE_ID_SYNAPTICS_WP	0x0008
 #define USB_DEVICE_ID_SYNAPTICS_COMP_TP	0x0009
 #define USB_DEVICE_ID_SYNAPTICS_WTP	0x0010
 #define USB_DEVICE_ID_SYNAPTICS_DPAD	0x0013
 #define USB_VENDOR_ID_THRUSTMASTER	0x044f
 #define USB_VENDOR_ID_TIVO		0x150a
 #define USB_DEVICE_ID_TIVO_SLIDE_BT	0x1200
 #define USB_DEVICE_ID_TIVO_SLIDE	0x1201
 #define USB_VENDOR_ID_TOPSEED		0x0766
 #define USB_DEVICE_ID_TOPSEED_CYBERLINK	0x0204
 #define USB_VENDOR_ID_TOPSEED2		0x1784
 #define USB_DEVICE_ID_TOPSEED2_RF_COMBO	0x0004
 #define USB_DEVICE_ID_TOPSEED2_PERIPAD_701	0x0016
 #define USB_VENDOR_ID_TOPMAX		0x0663
 #define USB_DEVICE_ID_TOPMAX_COBRAPAD	0x0103
 #define USB_VENDOR_ID_TOUCH_INTL	0x1e5e
 #define USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH	0x0313
 #define USB_VENDOR_ID_TOUCHPACK		0x1bfd
 #define USB_DEVICE_ID_TOUCHPACK_RTS	0x1688
 #define USB_VENDOR_ID_TURBOX		0x062a
 #define USB_DEVICE_ID_TURBOX_KEYBOARD	0x0201
 #define USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART	0x7100
 #define USB_VENDOR_ID_TWINHAN		0x6253
 #define USB_DEVICE_ID_TWINHAN_IR_REMOTE	0x0100
 #define USB_VENDOR_ID_UCLOGIC		0x5543
 #define USB_DEVICE_ID_UCLOGIC_TABLET_PF1209	0x0042
 #define USB_DEVICE_ID_UCLOGIC_TABLET_KNA5	0x6001
 #define USB_DEVICE_ID_UCLOGIC_TABLET_TWA60	0x0064
 #define USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U	0x0003
 #define USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U	0x0004
 #define USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U	0x0005
 #define USB_DEVICE_ID_UCLOGIC_TABLET_WP1062	0x0064
 #define USB_VENDOR_ID_UNITEC	0x227d
 #define USB_DEVICE_ID_UNITEC_USB_TOUCH_0709	0x0709
 #define USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19	0x0a19
 #define USB_VENDOR_ID_VERNIER		0x08f7
 #define USB_DEVICE_ID_VERNIER_LABPRO	0x0001
 #define USB_DEVICE_ID_VERNIER_GOTEMP	0x0002
 #define USB_DEVICE_ID_VERNIER_SKIP	0x0003
 #define USB_DEVICE_ID_VERNIER_CYCLOPS	0x0004
 #define USB_DEVICE_ID_VERNIER_LCSPEC	0x0006
 #define USB_VENDOR_ID_WACOM		0x056a
 #define USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH	0x81
 #define USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH   0x00BD
 #define USB_VENDOR_ID_WALTOP				0x172f
 #define USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH	0x0032
 #define USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH	0x0034
 #define USB_DEVICE_ID_WALTOP_Q_PAD			0x0037
 #define USB_DEVICE_ID_WALTOP_PID_0038			0x0038
 #define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH	0x0501
 #define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH	0x0500
 #define USB_VENDOR_ID_WISEGROUP		0x0925
 #define USB_DEVICE_ID_SMARTJOY_PLUS	0x0005
 #define USB_DEVICE_ID_1_PHIDGETSERVO_20	0x8101
 #define USB_DEVICE_ID_4_PHIDGETSERVO_20	0x8104
 #define USB_DEVICE_ID_8_8_4_IF_KIT	0x8201
 #define USB_DEVICE_ID_SUPER_JOY_BOX_3	0x8888
 #define USB_DEVICE_ID_QUAD_USB_JOYPAD	0x8800
 #define USB_DEVICE_ID_DUAL_USB_JOYPAD	0x8866
 #define USB_VENDOR_ID_WISEGROUP_LTD	0x6666
 #define USB_VENDOR_ID_WISEGROUP_LTD2	0x6677
 #define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802
 #define USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO 0x8801
 #define USB_DEVICE_ID_SUPER_DUAL_BOX_PRO 0x8802
 #define USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO 0x8804
 #define USB_VENDOR_ID_X_TENSIONS               0x1ae7
 #define USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE    0x9001
 #define USB_VENDOR_ID_XAT	0x2505
 #define USB_DEVICE_ID_XAT_CSR	0x0220
 #define USB_VENDOR_ID_XIROKU		0x1477
 #define USB_DEVICE_ID_XIROKU_SPX	0x1006
 #define USB_DEVICE_ID_XIROKU_MPX	0x1007
 #define USB_DEVICE_ID_XIROKU_CSR	0x100e
 #define USB_DEVICE_ID_XIROKU_SPX1	0x1021
 #define USB_DEVICE_ID_XIROKU_CSR1	0x1022
 #define USB_DEVICE_ID_XIROKU_MPX1	0x1023
 #define USB_DEVICE_ID_XIROKU_SPX2	0x1024
 #define USB_DEVICE_ID_XIROKU_CSR2	0x1025
 #define USB_DEVICE_ID_XIROKU_MPX2	0x1026
 #define USB_VENDOR_ID_YEALINK		0x6993
 #define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K	0xb001
 #define USB_VENDOR_ID_ZEROPLUS		0x0c12
 #define USB_VENDOR_ID_ZYDACRON	0x13EC
 #define USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL	0x0006
 #define USB_VENDOR_ID_PRIMAX	0x0461
 #define USB_DEVICE_ID_PRIMAX_KEYBOARD	0x4e05
 #endif

 /*
  * X-Box gamepad driver
  *
  * Copyright (c) 2002 Marko Friedemann <mfr@bmx-chemnitz.de>
  *               2004 Oliver Schwartz <Oliver.Schwartz@gmx.de>,
  *                    Steven Toth <steve@toth.demon.co.uk>,
  *                    Franz Lehner <franz@caos.at>,
  *                    Ivan Hawkes <blackhawk@ivanhawkes.com>
  *               2005 Dominic Cerquetti <binary1230@yahoo.com>
  *               2006 Adam Buchbinder <adam.buchbinder@gmail.com>
  *               2007 Jan Kratochvil <honza@jikos.cz>
  *               2010 Christoph Fritz <chf.fritz@googlemail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  *
  * This driver is based on:
  *  - information from     http://euc.jp/periphs/xbox-controller.ja.html
  *  - the iForce driver    drivers/char/joystick/iforce.c
  *  - the skeleton-driver  drivers/usb/usb-skeleton.c
  *  - Xbox 360 information http://www.free60.org/wiki/Gamepad
  *
  * Thanks to:
  *  - ITO Takayuki for providing essential xpad information on his website
  *  - Vojtech Pavlik     - iforce driver / input subsystem
  *  - Greg Kroah-Hartman - usb-skeleton driver
  *  - XBOX Linux project - extra USB id's
  *
  * TODO:
  *  - fine tune axes (especially trigger axes)
  *  - fix "analog" buttons (reported as digital now)
  *  - get rumble working
  *  - need USB IDs for other dance pads
  *
  * History:
  *
  * 2002-06-27 - 0.0.1 : first version, just said "XBOX HID controller"
  *
  * 2002-07-02 - 0.0.2 : basic working version
  *  - all axes and 9 of the 10 buttons work (german InterAct device)
  *  - the black button does not work
  *
  * 2002-07-14 - 0.0.3 : rework by Vojtech Pavlik
  *  - indentation fixes
  *  - usb + input init sequence fixes
  *
  * 2002-07-16 - 0.0.4 : minor changes, merge with Vojtech's v0.0.3
  *  - verified the lack of HID and report descriptors
  *  - verified that ALL buttons WORK
  *  - fixed d-pad to axes mapping
  *
  * 2002-07-17 - 0.0.5 : simplified d-pad handling
  *
  * 2004-10-02 - 0.0.6 : DDR pad support
  *  - borrowed from the XBOX linux kernel
  *  - USB id's for commonly used dance pads are present
  *  - dance pads will map D-PAD to buttons, not axes
  *  - pass the module paramater 'dpad_to_buttons' to force
  *    the D-PAD to map to buttons if your pad is not detected
  *
  * Later changes can be tracked in SCM.
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/stat.h>
 #include <linux/module.h>
 #include <linux/usb/input.h>
 #define DRIVER_AUTHOR "Marko Friedemann <mfr@bmx-chemnitz.de>"
 #define DRIVER_DESC "X-Box pad driver"
 #define XPAD_PKT_LEN 32
 /* xbox d-pads should map to buttons, as is required for DDR pads
    but we map them to axes when possible to simplify things */
 #define MAP_DPAD_TO_BUTTONS		(1 << 0)
 #define MAP_TRIGGERS_TO_BUTTONS		(1 << 1)
 #define MAP_STICKS_TO_NULL		(1 << 2)
 #define DANCEPAD_MAP_CONFIG	(MAP_DPAD_TO_BUTTONS |			\
 				MAP_TRIGGERS_TO_BUTTONS | MAP_STICKS_TO_NULL)
 #define XTYPE_XBOX        0
 #define XTYPE_XBOX360     1
 #define XTYPE_XBOX360W    2
 #define XTYPE_UNKNOWN     3
 static bool dpad_to_buttons;
 module_param(dpad_to_buttons, bool, S_IRUGO);
 MODULE_PARM_DESC(dpad_to_buttons, "Map D-PAD to buttons rather than axes for unknown pads");
 static bool triggers_to_buttons;
 module_param(triggers_to_buttons, bool, S_IRUGO);
 MODULE_PARM_DESC(triggers_to_buttons, "Map triggers to buttons rather than axes for unknown pads");
 static bool sticks_to_null;
 module_param(sticks_to_null, bool, S_IRUGO);
 MODULE_PARM_DESC(sticks_to_null, "Do not map sticks at all for unknown pads");
 static const struct xpad_device {
 	u16 idVendor;
 	u16 idProduct;
 	char *name;
 	u8 mapping;
 	u8 xtype;
 } xpad_device[] = {
 	{ 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", 0, XTYPE_XBOX },
 	{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },
 	{ 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", 0, XTYPE_XBOX },
 	{ 0x045e, 0x0287, "Microsoft Xbox Controller S", 0, XTYPE_XBOX },
 	{ 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
 	{ 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", DANCEPAD_MAP_CONFIG, XTYPE_XBOX },
 	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },
 	{ 0x046d, 0xc242, "Logitech Chillstream Controller", 0, XTYPE_XBOX360 },
 	{ 0x046d, 0xca84, "Logitech Xbox Cordless Controller", 0, XTYPE_XBOX },
 	{ 0x046d, 0xca88, "Logitech Compact Controller for Xbox", 0, XTYPE_XBOX },
 	{ 0x05fd, 0x1007, "Mad Catz Controller (unverified)", 0, XTYPE_XBOX },
 	{ 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", 0, XTYPE_XBOX },
 	{ 0x0738, 0x4516, "Mad Catz Control Pad", 0, XTYPE_XBOX },
 	{ 0x0738, 0x4522, "Mad Catz LumiCON", 0, XTYPE_XBOX },
 	{ 0x0738, 0x4526, "Mad Catz Control Pad Pro", 0, XTYPE_XBOX },
 	{ 0x0738, 0x4536, "Mad Catz MicroCON", 0, XTYPE_XBOX },
 	{ 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 	{ 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", 0, XTYPE_XBOX },
 	{ 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
 	{ 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 	{ 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 	{ 0x0c12, 0x8802, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
 	{ 0x0c12, 0x880a, "Pelican Eclipse PL-2023", 0, XTYPE_XBOX },
 	{ 0x0c12, 0x8810, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
 	{ 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", 0, XTYPE_XBOX },
 	{ 0x0e4c, 0x1097, "Radica Gamester Controller", 0, XTYPE_XBOX },
 	{ 0x0e4c, 0x2390, "Radica Games Jtech Controller", 0, XTYPE_XBOX },
 	{ 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", 0, XTYPE_XBOX },
 	{ 0x0e6f, 0x0005, "Eclipse wireless Controller", 0, XTYPE_XBOX },
 	{ 0x0e6f, 0x0006, "Edge wireless Controller", 0, XTYPE_XBOX },
 	{ 0x0e6f, 0x0006, "Pelican 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
 	{ 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
 	{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },
 	{ 0x0f30, 0x0202, "Joytech Advanced Controller", 0, XTYPE_XBOX },
 	{ 0x0f30, 0x8888, "BigBen XBMiniPad Controller", 0, XTYPE_XBOX },
 	{ 0x102c, 0xff0c, "Joytech Wireless Advanced Controller", 0, XTYPE_XBOX },
 	{ 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 	{ 0x12ab, 0x0004, "Honey Bee Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 	{ 0x0e6f, 0x0105, "HSM3 Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 	{ 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", 0, XTYPE_XBOX360 },
 	{ 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 	{ 0x146b, 0x0601, "BigBen Interactive XBOX 360 Controller", 0, XTYPE_XBOX360 },
 	{ 0x045e, 0x028e, "Microsoft X-Box 360 pad", 0, XTYPE_XBOX360 },
 	{ 0x1bad, 0x0002, "Harmonix Rock Band Guitar", 0, XTYPE_XBOX360 },
 	{ 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 	{ 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 	{ 0x0f0d, 0x000d, "Hori Fighting Stick EX2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 	{ 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
 	{ 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
 };
 /* buttons shared with xbox and xbox360 */
 static const signed short xpad_common_btn[] = {
 	BTN_A, BTN_B, BTN_X, BTN_Y,			/* "analog" buttons */
 	BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR,	/* start/back/sticks */
 	-1						/* terminating entry */
 };
 /* original xbox controllers only */
 static const signed short xpad_btn[] = {
 	BTN_C, BTN_Z,		/* "analog" buttons */
 	-1			/* terminating entry */
 };
 /* used when dpad is mapped to buttons */
 static const signed short xpad_btn_pad[] = {
 	BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2,		/* d-pad left, right */
 	BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4,		/* d-pad up, down */
 	-1				/* terminating entry */
 };
 /* used when triggers are mapped to buttons */
 static const signed short xpad_btn_triggers[] = {
 	BTN_TL2, BTN_TR2,		/* triggers left/right */
 	-1
 };
 static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
 	BTN_TL, BTN_TR,		/* Button LB/RB */
 	BTN_MODE,		/* The big X button */
 	-1
 };
 static const signed short xpad_abs[] = {
 	ABS_X, ABS_Y,		/* left stick */
 	ABS_RX, ABS_RY,		/* right stick */
 	-1			/* terminating entry */
 };
 /* used when dpad is mapped to axes */
 static const signed short xpad_abs_pad[] = {
 	ABS_HAT0X, ABS_HAT0Y,	/* d-pad axes */
 	-1			/* terminating entry */
 };
 /* used when triggers are mapped to axes */
 static const signed short xpad_abs_triggers[] = {
 	ABS_Z, ABS_RZ,		/* triggers left/right */
 	-1
 };
 /* Xbox 360 has a vendor-specific class, so we cannot match it with only
  * USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
  * match against vendor id as well. Wired Xbox 360 devices have protocol 1,
  * wireless controllers have protocol 129. */
 #define XPAD_XBOX360_VENDOR_PROTOCOL(vend,pr) \
 	.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
 	.idVendor = (vend), \
 	.bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
 	.bInterfaceSubClass = 93, \
 	.bInterfaceProtocol = (pr)
 #define XPAD_XBOX360_VENDOR(vend) \
 	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
 	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
 static struct usb_device_id xpad_table [] = {
 	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* X-Box USB-IF not approved class */
 	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft X-Box 360 controllers */
 	XPAD_XBOX360_VENDOR(0x046d),		/* Logitech X-Box 360 style controllers */
 	XPAD_XBOX360_VENDOR(0x0738),		/* Mad Catz X-Box 360 controllers */
+	{ USB_DEVICE(0x0738, 0x4540) },		/* Mad Catz Beat Pad */
 	XPAD_XBOX360_VENDOR(0x0e6f),		/* 0x0e6f X-Box 360 controllers */
 	XPAD_XBOX360_VENDOR(0x12ab),		/* X-Box 360 dance pads */
 	XPAD_XBOX360_VENDOR(0x1430),		/* RedOctane X-Box 360 controllers */
 	XPAD_XBOX360_VENDOR(0x146b),		/* BigBen Interactive Controllers */
 	XPAD_XBOX360_VENDOR(0x1bad),		/* Harminix Rock Band Guitar and Drums */
 	XPAD_XBOX360_VENDOR(0x0f0d),            /* Hori Controllers */
 	{ }
 };
 MODULE_DEVICE_TABLE (usb, xpad_table);
 struct usb_xpad {
 	struct input_dev *dev;		/* input device interface */
 	struct usb_device *udev;	/* usb device */
 	int pad_present;
 	struct urb *irq_in;		/* urb for interrupt in report */
 	unsigned char *idata;		/* input data */
 	dma_addr_t idata_dma;
 	struct urb *bulk_out;
 	unsigned char *bdata;
 #if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
 	struct urb *irq_out;		/* urb for interrupt out report */
 	unsigned char *odata;		/* output data */
 	dma_addr_t odata_dma;
 	struct mutex odata_mutex;
 #endif
 #if defined(CONFIG_JOYSTICK_XPAD_LEDS)
 	struct xpad_led *led;
 #endif
 	char phys[64];			/* physical device path */
 	int mapping;			/* map d-pad to buttons or to axes */
 	int xtype;			/* type of xbox device */
 };
 /*
  *	xpad_process_packet
  *
  *	Completes a request by converting the data into events for the
  *	input subsystem.
  *
  *	The used report descriptor was taken from ITO Takayukis website:
  *	 http://euc.jp/periphs/xbox-controller.ja.html
  */
 static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
 {
 	struct input_dev *dev = xpad->dev;
 	if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 		/* left stick */
 		input_report_abs(dev, ABS_X,
 				 (__s16) le16_to_cpup((__le16 *)(data + 12)));
 		input_report_abs(dev, ABS_Y,
 				 ~(__s16) le16_to_cpup((__le16 *)(data + 14)));
 		/* right stick */
 		input_report_abs(dev, ABS_RX,
 				 (__s16) le16_to_cpup((__le16 *)(data + 16)));
 		input_report_abs(dev, ABS_RY,
 				 ~(__s16) le16_to_cpup((__le16 *)(data + 18)));
 	}
 	/* triggers left/right */
 	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 		input_report_key(dev, BTN_TL2, data[10]);
 		input_report_key(dev, BTN_TR2, data[11]);
 	} else {
 		input_report_abs(dev, ABS_Z, data[10]);
 		input_report_abs(dev, ABS_RZ, data[11]);
 	}
 	/* digital pad */
 	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 		/* dpad as buttons (left, right, up, down) */
 		input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
 		input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
 		input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
 		input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
 	} else {
 		input_report_abs(dev, ABS_HAT0X,
 				 !!(data[2] & 0x08) - !!(data[2] & 0x04));
 		input_report_abs(dev, ABS_HAT0Y,
 				 !!(data[2] & 0x02) - !!(data[2] & 0x01));
 	}
 	/* start/back buttons and stick press left/right */
 	input_report_key(dev, BTN_START,  data[2] & 0x10);
 	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
 	input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
 	input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
 	/* "analog" buttons A, B, X, Y */
 	input_report_key(dev, BTN_A, data[4]);
 	input_report_key(dev, BTN_B, data[5]);
 	input_report_key(dev, BTN_X, data[6]);
 	input_report_key(dev, BTN_Y, data[7]);
 	/* "analog" buttons black, white */
 	input_report_key(dev, BTN_C, data[8]);
 	input_report_key(dev, BTN_Z, data[9]);
 	input_sync(dev);
 }
 /*
  *	xpad360_process_packet
  *
  *	Completes a request by converting the data into events for the
  *	input subsystem. It is version for xbox 360 controller
  *
  *	The used report descriptor was taken from:
  *		http://www.free60.org/wiki/Gamepad
  */
 static void xpad360_process_packet(struct usb_xpad *xpad,
 				   u16 cmd, unsigned char *data)
 {
 	struct input_dev *dev = xpad->dev;
 	/* digital pad */
 	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 		/* dpad as buttons (left, right, up, down) */
 		input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
 		input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
 		input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
 		input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
 	} else {
 		input_report_abs(dev, ABS_HAT0X,
 				 !!(data[2] & 0x08) - !!(data[2] & 0x04));
 		input_report_abs(dev, ABS_HAT0Y,
 				 !!(data[2] & 0x02) - !!(data[2] & 0x01));
 	}
 	/* start/back buttons */
 	input_report_key(dev, BTN_START,  data[2] & 0x10);
 	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
 	/* stick press left/right */
 	input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
 	input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
 	/* buttons A,B,X,Y,TL,TR and MODE */
 	input_report_key(dev, BTN_A,	data[3] & 0x10);
 	input_report_key(dev, BTN_B,	data[3] & 0x20);
 	input_report_key(dev, BTN_X,	data[3] & 0x40);
 	input_report_key(dev, BTN_Y,	data[3] & 0x80);
 	input_report_key(dev, BTN_TL,	data[3] & 0x01);
 	input_report_key(dev, BTN_TR,	data[3] & 0x02);
 	input_report_key(dev, BTN_MODE,	data[3] & 0x04);
 	if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 		/* left stick */
 		input_report_abs(dev, ABS_X,
 				 (__s16) le16_to_cpup((__le16 *)(data + 6)));
 		input_report_abs(dev, ABS_Y,
 				 ~(__s16) le16_to_cpup((__le16 *)(data + 8)));
 		/* right stick */
 		input_report_abs(dev, ABS_RX,
 				 (__s16) le16_to_cpup((__le16 *)(data + 10)));
 		input_report_abs(dev, ABS_RY,
 				 ~(__s16) le16_to_cpup((__le16 *)(data + 12)));
 	}
 	/* triggers left/right */
 	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 		input_report_key(dev, BTN_TL2, data[4]);
 		input_report_key(dev, BTN_TR2, data[5]);
 	} else {
 		input_report_abs(dev, ABS_Z, data[4]);
 		input_report_abs(dev, ABS_RZ, data[5]);
 	}
 	input_sync(dev);
 }
 /*
  * xpad360w_process_packet
  *
  * Completes a request by converting the data into events for the
  * input subsystem. It is version for xbox 360 wireless controller.
  *
  * Byte.Bit
  * 00.1 - Status change: The controller or headset has connected/disconnected
  *                       Bits 01.7 and 01.6 are valid
  * 01.7 - Controller present
  * 01.6 - Headset present
  * 01.1 - Pad state (Bytes 4+) valid
  *
  */
 static void xpad360w_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
 {
 	/* Presence change */
 	if (data[0] & 0x08) {
 		if (data[1] & 0x80) {
 			xpad->pad_present = 1;
 			usb_submit_urb(xpad->bulk_out, GFP_ATOMIC);
 		} else
 			xpad->pad_present = 0;
 	}
 	/* Valid pad data */
 	if (!(data[1] & 0x1))
 		return;
 	xpad360_process_packet(xpad, cmd, &data[4]);
 }
 static void xpad_irq_in(struct urb *urb)
 {
 	struct usb_xpad *xpad = urb->context;
 	int retval, status;
 	status = urb->status;
 	switch (status) {
 	case 0:
 		/* success */
 		break;
 	case -ECONNRESET:
 	case -ENOENT:
 	case -ESHUTDOWN:
 		/* this urb is terminated, clean up */
 		dbg("%s - urb shutting down with status: %d",
 			__func__, status);
 		return;
 	default:
 		dbg("%s - nonzero urb status received: %d",
 			__func__, status);
 		goto exit;
 	}
 	switch (xpad->xtype) {
 	case XTYPE_XBOX360:
 		xpad360_process_packet(xpad, 0, xpad->idata);
 		break;
 	case XTYPE_XBOX360W:
 		xpad360w_process_packet(xpad, 0, xpad->idata);
 		break;
 	default:
 		xpad_process_packet(xpad, 0, xpad->idata);
 	}
 exit:
 	retval = usb_submit_urb(urb, GFP_ATOMIC);
 	if (retval)
 		err ("%s - usb_submit_urb failed with result %d",
 		     __func__, retval);
 }
 static void xpad_bulk_out(struct urb *urb)
 {
 	switch (urb->status) {
 	case 0:
 		/* success */
 		break;
 	case -ECONNRESET:
 	case -ENOENT:
 	case -ESHUTDOWN:
 		/* this urb is terminated, clean up */
 		dbg("%s - urb shutting down with status: %d", __func__, urb->status);
 		break;
 	default:
 		dbg("%s - nonzero urb status received: %d", __func__, urb->status);
 	}
 }
 #if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
 static void xpad_irq_out(struct urb *urb)
 {
 	int retval, status;
 	status = urb->status;
 	switch (status) {
 	case 0:
 		/* success */
 		return;
 	case -ECONNRESET:
 	case -ENOENT:
 	case -ESHUTDOWN:
 		/* this urb is terminated, clean up */
 		dbg("%s - urb shutting down with status: %d", __func__, status);
 		return;
 	default:
 		dbg("%s - nonzero urb status received: %d", __func__, status);
 		goto exit;
 	}
 exit:
 	retval = usb_submit_urb(urb, GFP_ATOMIC);
 	if (retval)
 		err("%s - usb_submit_urb failed with result %d",
 		    __func__, retval);
 }
 static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
 {
 	struct usb_endpoint_descriptor *ep_irq_out;
 	int error;
 	if (xpad->xtype == XTYPE_UNKNOWN)
 		return 0;
 	xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
 					 GFP_KERNEL, &xpad->odata_dma);
 	if (!xpad->odata) {
 		error = -ENOMEM;
 		goto fail1;
 	}
 	mutex_init(&xpad->odata_mutex);
 	xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
 	if (!xpad->irq_out) {
 		error = -ENOMEM;
 		goto fail2;
 	}
 	ep_irq_out = &intf->cur_altsetting->endpoint[1].desc;
 	usb_fill_int_urb(xpad->irq_out, xpad->udev,
 			 usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),
 			 xpad->odata, XPAD_PKT_LEN,
 			 xpad_irq_out, xpad, ep_irq_out->bInterval);
 	xpad->irq_out->transfer_dma = xpad->odata_dma;
 	xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 	return 0;
  fail2:	usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
  fail1:	return error;
 }
 static void xpad_stop_output(struct usb_xpad *xpad)
 {
 	if (xpad->xtype != XTYPE_UNKNOWN)
 		usb_kill_urb(xpad->irq_out);
 }
 static void xpad_deinit_output(struct usb_xpad *xpad)
 {
 	if (xpad->xtype != XTYPE_UNKNOWN) {
 		usb_free_urb(xpad->irq_out);
 		usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
 				xpad->odata, xpad->odata_dma);
 	}
 }
 #else
 static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad) { return 0; }
 static void xpad_deinit_output(struct usb_xpad *xpad) {}
 static void xpad_stop_output(struct usb_xpad *xpad) {}
 #endif
 #ifdef CONFIG_JOYSTICK_XPAD_FF
 static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
 {
 	struct usb_xpad *xpad = input_get_drvdata(dev);
 	if (effect->type == FF_RUMBLE) {
 		__u16 strong = effect->u.rumble.strong_magnitude;
 		__u16 weak = effect->u.rumble.weak_magnitude;
 		switch (xpad->xtype) {
 		case XTYPE_XBOX:
 			xpad->odata[0] = 0x00;
 			xpad->odata[1] = 0x06;
 			xpad->odata[2] = 0x00;
 			xpad->odata[3] = strong / 256;	/* left actuator */
 			xpad->odata[4] = 0x00;
 			xpad->odata[5] = weak / 256;	/* right actuator */
 			xpad->irq_out->transfer_buffer_length = 6;
 			return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
 		case XTYPE_XBOX360:
 			xpad->odata[0] = 0x00;
 			xpad->odata[1] = 0x08;
 			xpad->odata[2] = 0x00;
 			xpad->odata[3] = strong / 256;  /* left actuator? */
 			xpad->odata[4] = weak / 256;	/* right actuator? */
 			xpad->odata[5] = 0x00;
 			xpad->odata[6] = 0x00;
 			xpad->odata[7] = 0x00;
 			xpad->irq_out->transfer_buffer_length = 8;
 			return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
 		case XTYPE_XBOX360W:
 			xpad->odata[0] = 0x00;
 			xpad->odata[1] = 0x01;
 			xpad->odata[2] = 0x0F;
 			xpad->odata[3] = 0xC0;
 			xpad->odata[4] = 0x00;
 			xpad->odata[5] = strong / 256;
 			xpad->odata[6] = weak / 256;
 			xpad->odata[7] = 0x00;
 			xpad->odata[8] = 0x00;
 			xpad->odata[9] = 0x00;
 			xpad->odata[10] = 0x00;
 			xpad->odata[11] = 0x00;
 			xpad->irq_out->transfer_buffer_length = 12;
 			return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
 		default:
 			dbg("%s - rumble command sent to unsupported xpad type: %d",
 				__func__, xpad->xtype);
 			return -1;
 		}
 	}
 	return 0;
 }
 static int xpad_init_ff(struct usb_xpad *xpad)
 {
 	if (xpad->xtype == XTYPE_UNKNOWN)
 		return 0;
 	input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
 	return input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
 }
 #else
 static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
 #endif
 #if defined(CONFIG_JOYSTICK_XPAD_LEDS)
 #include <linux/leds.h>
 struct xpad_led {
 	char name[16];
 	struct led_classdev led_cdev;
 	struct usb_xpad *xpad;
 };
 static void xpad_send_led_command(struct usb_xpad *xpad, int command)
 {
 	if (command >= 0 && command < 14) {
 		mutex_lock(&xpad->odata_mutex);
 		xpad->odata[0] = 0x01;
 		xpad->odata[1] = 0x03;
 		xpad->odata[2] = command;
 		xpad->irq_out->transfer_buffer_length = 3;
 		usb_submit_urb(xpad->irq_out, GFP_KERNEL);
 		mutex_unlock(&xpad->odata_mutex);
 	}
 }
 static void xpad_led_set(struct led_classdev *led_cdev,
 			 enum led_brightness value)
 {
 	struct xpad_led *xpad_led = container_of(led_cdev,
 						 struct xpad_led, led_cdev);
 	xpad_send_led_command(xpad_led->xpad, value);
 }
 static int xpad_led_probe(struct usb_xpad *xpad)
 {
 	static atomic_t led_seq	= ATOMIC_INIT(0);
 	long led_no;
 	struct xpad_led *led;
 	struct led_classdev *led_cdev;
 	int error;
 	if (xpad->xtype != XTYPE_XBOX360)
 		return 0;
 	xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
 	if (!led)
 		return -ENOMEM;
 	led_no = (long)atomic_inc_return(&led_seq) - 1;
 	snprintf(led->name, sizeof(led->name), "xpad%ld", led_no);
 	led->xpad = xpad;
 	led_cdev = &led->led_cdev;
 	led_cdev->name = led->name;
 	led_cdev->brightness_set = xpad_led_set;
 	error = led_classdev_register(&xpad->udev->dev, led_cdev);
 	if (error) {
 		kfree(led);
 		xpad->led = NULL;
 		return error;
 	}
 	/*
 	 * Light up the segment corresponding to controller number
 	 */
 	xpad_send_led_command(xpad, (led_no % 4) + 2);
 	return 0;
 }
 static void xpad_led_disconnect(struct usb_xpad *xpad)
 {
 	struct xpad_led *xpad_led = xpad->led;
 	if (xpad_led) {
 		led_classdev_unregister(&xpad_led->led_cdev);
 		kfree(xpad_led);
 	}
 }
 #else
 static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
 static void xpad_led_disconnect(struct usb_xpad *xpad) { }
 #endif
 static int xpad_open(struct input_dev *dev)
 {
 	struct usb_xpad *xpad = input_get_drvdata(dev);
 	/* URB was submitted in probe */
 	if(xpad->xtype == XTYPE_XBOX360W)
 		return 0;
 	xpad->irq_in->dev = xpad->udev;
 	if (usb_submit_urb(xpad->irq_in, GFP_KERNEL))
 		return -EIO;
 	return 0;
 }
 static void xpad_close(struct input_dev *dev)
 {
 	struct usb_xpad *xpad = input_get_drvdata(dev);
 	if (xpad->xtype != XTYPE_XBOX360W)
 		usb_kill_urb(xpad->irq_in);
 	xpad_stop_output(xpad);
 }
 static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
 {
 	set_bit(abs, input_dev->absbit);
 	switch (abs) {
 	case ABS_X:
 	case ABS_Y:
 	case ABS_RX:
 	case ABS_RY:	/* the two sticks */
 		input_set_abs_params(input_dev, abs, -32768, 32767, 16, 128);
 		break;
 	case ABS_Z:
 	case ABS_RZ:	/* the triggers (if mapped to axes) */
 		input_set_abs_params(input_dev, abs, 0, 255, 0, 0);
 		break;
 	case ABS_HAT0X:
 	case ABS_HAT0Y:	/* the d-pad (only if dpad is mapped to axes */
 		input_set_abs_params(input_dev, abs, -1, 1, 0, 0);
 		break;
 	}
 }
 static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
 	struct usb_device *udev = interface_to_usbdev(intf);
 	struct usb_xpad *xpad;
 	struct input_dev *input_dev;
 	struct usb_endpoint_descriptor *ep_irq_in;
 	int i, error;
 	for (i = 0; xpad_device[i].idVendor; i++) {
 		if ((le16_to_cpu(udev->descriptor.idVendor) == xpad_device[i].idVendor) &&
 		    (le16_to_cpu(udev->descriptor.idProduct) == xpad_device[i].idProduct))
 			break;
 	}
 	xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
 	input_dev = input_allocate_device();
 	if (!xpad || !input_dev) {
 		error = -ENOMEM;
 		goto fail1;
 	}
 	xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
 					 GFP_KERNEL, &xpad->idata_dma);
 	if (!xpad->idata) {
 		error = -ENOMEM;
 		goto fail1;
 	}
 	xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);
 	if (!xpad->irq_in) {
 		error = -ENOMEM;
 		goto fail2;
 	}
 	xpad->udev = udev;
 	xpad->mapping = xpad_device[i].mapping;
 	xpad->xtype = xpad_device[i].xtype;
 	if (xpad->xtype == XTYPE_UNKNOWN) {
 		if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {
 			if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)
 				xpad->xtype = XTYPE_XBOX360W;
 			else
 				xpad->xtype = XTYPE_XBOX360;
 		} else
 			xpad->xtype = XTYPE_XBOX;
 		if (dpad_to_buttons)
 			xpad->mapping |= MAP_DPAD_TO_BUTTONS;
 		if (triggers_to_buttons)
 			xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;
 		if (sticks_to_null)
 			xpad->mapping |= MAP_STICKS_TO_NULL;
 	}
 	xpad->dev = input_dev;
 	usb_make_path(udev, xpad->phys, sizeof(xpad->phys));
 	strlcat(xpad->phys, "/input0", sizeof(xpad->phys));
 	input_dev->name = xpad_device[i].name;
 	input_dev->phys = xpad->phys;
 	usb_to_input_id(udev, &input_dev->id);
 	input_dev->dev.parent = &intf->dev;
 	input_set_drvdata(input_dev, xpad);
 	input_dev->open = xpad_open;
 	input_dev->close = xpad_close;
 	input_dev->evbit[0] = BIT_MASK(EV_KEY);
 	if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 		input_dev->evbit[0] |= BIT_MASK(EV_ABS);
 		/* set up axes */
 		for (i = 0; xpad_abs[i] >= 0; i++)
 			xpad_set_up_abs(input_dev, xpad_abs[i]);
 	}
 	/* set up standard buttons */
 	for (i = 0; xpad_common_btn[i] >= 0; i++)
 		__set_bit(xpad_common_btn[i], input_dev->keybit);
 	/* set up model-specific ones */
 	if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W) {
 		for (i = 0; xpad360_btn[i] >= 0; i++)
 			__set_bit(xpad360_btn[i], input_dev->keybit);
 	} else {
 		for (i = 0; xpad_btn[i] >= 0; i++)
 			__set_bit(xpad_btn[i], input_dev->keybit);
 	}
 	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 		for (i = 0; xpad_btn_pad[i] >= 0; i++)
 			__set_bit(xpad_btn_pad[i], input_dev->keybit);
 	} else {
 		for (i = 0; xpad_abs_pad[i] >= 0; i++)
 		    xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
 	}
 	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 		for (i = 0; xpad_btn_triggers[i] >= 0; i++)
 			__set_bit(xpad_btn_triggers[i], input_dev->keybit);
 	} else {
 		for (i = 0; xpad_abs_triggers[i] >= 0; i++)
 			xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);
 	}
 	error = xpad_init_output(intf, xpad);
 	if (error)
 		goto fail3;
 	error = xpad_init_ff(xpad);
 	if (error)
 		goto fail4;
 	error = xpad_led_probe(xpad);
 	if (error)
 		goto fail5;
 	ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;
 	usb_fill_int_urb(xpad->irq_in, udev,
 			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
 			 xpad->idata, XPAD_PKT_LEN, xpad_irq_in,
 			 xpad, ep_irq_in->bInterval);
 	xpad->irq_in->transfer_dma = xpad->idata_dma;
 	xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 	error = input_register_device(xpad->dev);
 	if (error)
 		goto fail6;
 	usb_set_intfdata(intf, xpad);
 	if (xpad->xtype == XTYPE_XBOX360W) {
 		/*
 		 * Setup the message to set the LEDs on the
 		 * controller when it shows up
 		 */
 		xpad->bulk_out = usb_alloc_urb(0, GFP_KERNEL);
 		if (!xpad->bulk_out) {
 			error = -ENOMEM;
 			goto fail7;
 		}
 		xpad->bdata = kzalloc(XPAD_PKT_LEN, GFP_KERNEL);
 		if (!xpad->bdata) {
 			error = -ENOMEM;
 			goto fail8;
 		}
 		xpad->bdata[2] = 0x08;
 		switch (intf->cur_altsetting->desc.bInterfaceNumber) {
 		case 0:
 			xpad->bdata[3] = 0x42;
 			break;
 		case 2:
 			xpad->bdata[3] = 0x43;
 			break;
 		case 4:
 			xpad->bdata[3] = 0x44;
 			break;
 		case 6:
 			xpad->bdata[3] = 0x45;
 		}
 		ep_irq_in = &intf->cur_altsetting->endpoint[1].desc;
 		usb_fill_bulk_urb(xpad->bulk_out, udev,
 				usb_sndbulkpipe(udev, ep_irq_in->bEndpointAddress),
 				xpad->bdata, XPAD_PKT_LEN, xpad_bulk_out, xpad);
 		/*
 		 * Submit the int URB immediately rather than waiting for open
 		 * because we get status messages from the device whether
 		 * or not any controllers are attached.  In fact, it's
 		 * exactly the message that a controller has arrived that
 		 * we're waiting for.
 		 */
 		xpad->irq_in->dev = xpad->udev;
 		error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
 		if (error)
 			goto fail9;
 	}
 	return 0;
  fail9:	kfree(xpad->bdata);
  fail8:	usb_free_urb(xpad->bulk_out);
  fail7:	input_unregister_device(input_dev);
 	input_dev = NULL;
  fail6:	xpad_led_disconnect(xpad);
  fail5:	if (input_dev)
 		input_ff_destroy(input_dev);
  fail4:	xpad_deinit_output(xpad);
  fail3:	usb_free_urb(xpad->irq_in);
  fail2:	usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
  fail1:	input_free_device(input_dev);
 	kfree(xpad);
 	return error;
 }
 static void xpad_disconnect(struct usb_interface *intf)
 {
 	struct usb_xpad *xpad = usb_get_intfdata (intf);
 	xpad_led_disconnect(xpad);
 	input_unregister_device(xpad->dev);
 	xpad_deinit_output(xpad);
 	if (xpad->xtype == XTYPE_XBOX360W) {
 		usb_kill_urb(xpad->bulk_out);
 		usb_free_urb(xpad->bulk_out);
 		usb_kill_urb(xpad->irq_in);
 	}
 	usb_free_urb(xpad->irq_in);
 	usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
 			xpad->idata, xpad->idata_dma);
 	kfree(xpad->bdata);
 	kfree(xpad);
 	usb_set_intfdata(intf, NULL);
 }
 static struct usb_driver xpad_driver = {
 	.name		= "xpad",
 	.probe		= xpad_probe,
 	.disconnect	= xpad_disconnect,
 	.id_table	= xpad_table,
 };
 module_usb_driver(xpad_driver);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");