?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] NFS: Fix race in nfs_release_page()
[linux-2.6/mini2440.git] / arch / powerpc / platforms / powermac / pfunc_core.c
blob7651f278615a307dd701fe900a6bcc6b5fbf67bc
1 /*
2 *
3 * FIXME: Properly make this race free with refcounting etc...
4 *
5 * FIXME: LOCKING !!!
6 */
7
8 #include <linux/init.h>
9 #include <linux/delay.h>
10 #include <linux/kernel.h>
11 #include <linux/spinlock.h>
12 #include <linux/module.h>
13 #include <linux/mutex.h>
14
15 #include <asm/semaphore.h>
16 #include <asm/prom.h>
17 #include <asm/pmac_pfunc.h>
18
19 /* Debug */
20 #define LOG_PARSE(fmt...)
21 #define LOG_ERROR(fmt...) printk(fmt)
22 #define LOG_BLOB(t,b,c)
23
24 #undef DEBUG
25 #ifdef DEBUG
26 #define DBG(fmt...) printk(fmt)
27 #else
28 #define DBG(fmt...)
29 #endif
30
31 /* Command numbers */
32 #define PMF_CMD_LIST 0
33 #define PMF_CMD_WRITE_GPIO 1
34 #define PMF_CMD_READ_GPIO 2
35 #define PMF_CMD_WRITE_REG32 3
36 #define PMF_CMD_READ_REG32 4
37 #define PMF_CMD_WRITE_REG16 5
38 #define PMF_CMD_READ_REG16 6
39 #define PMF_CMD_WRITE_REG8 7
40 #define PMF_CMD_READ_REG8 8
41 #define PMF_CMD_DELAY 9
42 #define PMF_CMD_WAIT_REG32 10
43 #define PMF_CMD_WAIT_REG16 11
44 #define PMF_CMD_WAIT_REG8 12
45 #define PMF_CMD_READ_I2C 13
46 #define PMF_CMD_WRITE_I2C 14
47 #define PMF_CMD_RMW_I2C 15
48 #define PMF_CMD_GEN_I2C 16
49 #define PMF_CMD_SHIFT_BYTES_RIGHT 17
50 #define PMF_CMD_SHIFT_BYTES_LEFT 18
51 #define PMF_CMD_READ_CFG 19
52 #define PMF_CMD_WRITE_CFG 20
53 #define PMF_CMD_RMW_CFG 21
54 #define PMF_CMD_READ_I2C_SUBADDR 22
55 #define PMF_CMD_WRITE_I2C_SUBADDR 23
56 #define PMF_CMD_SET_I2C_MODE 24
57 #define PMF_CMD_RMW_I2C_SUBADDR 25
58 #define PMF_CMD_READ_REG32_MASK_SHR_XOR 26
59 #define PMF_CMD_READ_REG16_MASK_SHR_XOR 27
60 #define PMF_CMD_READ_REG8_MASK_SHR_XOR 28
61 #define PMF_CMD_WRITE_REG32_SHL_MASK 29
62 #define PMF_CMD_WRITE_REG16_SHL_MASK 30
63 #define PMF_CMD_WRITE_REG8_SHL_MASK 31
64 #define PMF_CMD_MASK_AND_COMPARE 32
65 #define PMF_CMD_COUNT 33
66
67 /* This structure holds the state of the parser while walking through
68 * a function definition
69 */
70 struct pmf_cmd {
71 const void *cmdptr;
72 const void *cmdend;
73 struct pmf_function *func;
74 void *instdata;
75 struct pmf_args *args;
76 int error;
77 };
78
79 #if 0
80 /* Debug output */
81 static void print_blob(const char *title, const void *blob, int bytes)
82 {
83 printk("%s", title);
84 while(bytes--) {
85 printk("%02x ", *((u8 *)blob));
86 blob += 1;
87 }
88 printk("\n");
89 }
90 #endif
91
92 /*
93 * Parser helpers
94 */
95
96 static u32 pmf_next32(struct pmf_cmd *cmd)
97 {
98 u32 value;
99 if ((cmd->cmdend - cmd->cmdptr) < 4) {
100 cmd->error = 1;
101 return 0;
102 }
103 value = *((u32 *)cmd->cmdptr);
104 cmd->cmdptr += 4;
105 return value;
106 }
107
108 static const void* pmf_next_blob(struct pmf_cmd *cmd, int count)
109 {
110 const void *value;
111 if ((cmd->cmdend - cmd->cmdptr) < count) {
112 cmd->error = 1;
113 return NULL;
114 }
115 value = cmd->cmdptr;
116 cmd->cmdptr += count;
117 return value;
118 }
119
120 /*
121 * Individual command parsers
122 */
123
124 #define PMF_PARSE_CALL(name, cmd, handlers, p...) \
125 do { \
126 if (cmd->error) \
127 return -ENXIO; \
128 if (handlers == NULL) \
129 return 0; \
130 if (handlers->name) \
131 return handlers->name(cmd->func, cmd->instdata, \
132 cmd->args, p); \
133 return -1; \
134 } while(0) \
135
136
137 static int pmf_parser_write_gpio(struct pmf_cmd *cmd, struct pmf_handlers *h)
138 {
139 u8 value = (u8)pmf_next32(cmd);
140 u8 mask = (u8)pmf_next32(cmd);
141
142 LOG_PARSE("pmf: write_gpio(value: %02x, mask: %02x)\n", value, mask);
143
144 PMF_PARSE_CALL(write_gpio, cmd, h, value, mask);
145 }
146
147 static int pmf_parser_read_gpio(struct pmf_cmd *cmd, struct pmf_handlers *h)
148 {
149 u8 mask = (u8)pmf_next32(cmd);
150 int rshift = (int)pmf_next32(cmd);
151 u8 xor = (u8)pmf_next32(cmd);
152
153 LOG_PARSE("pmf: read_gpio(mask: %02x, rshift: %d, xor: %02x)\n",
154 mask, rshift, xor);
155
156 PMF_PARSE_CALL(read_gpio, cmd, h, mask, rshift, xor);
157 }
158
159 static int pmf_parser_write_reg32(struct pmf_cmd *cmd, struct pmf_handlers *h)
160 {
161 u32 offset = pmf_next32(cmd);
162 u32 value = pmf_next32(cmd);
163 u32 mask = pmf_next32(cmd);
164
165 LOG_PARSE("pmf: write_reg32(offset: %08x, value: %08x, mask: %08x)\n",
166 offset, value, mask);
167
168 PMF_PARSE_CALL(write_reg32, cmd, h, offset, value, mask);
169 }
170
171 static int pmf_parser_read_reg32(struct pmf_cmd *cmd, struct pmf_handlers *h)
172 {
173 u32 offset = pmf_next32(cmd);
174
175 LOG_PARSE("pmf: read_reg32(offset: %08x)\n", offset);
176
177 PMF_PARSE_CALL(read_reg32, cmd, h, offset);
178 }
179
180
181 static int pmf_parser_write_reg16(struct pmf_cmd *cmd, struct pmf_handlers *h)
182 {
183 u32 offset = pmf_next32(cmd);
184 u16 value = (u16)pmf_next32(cmd);
185 u16 mask = (u16)pmf_next32(cmd);
186
187 LOG_PARSE("pmf: write_reg16(offset: %08x, value: %04x, mask: %04x)\n",
188 offset, value, mask);
189
190 PMF_PARSE_CALL(write_reg16, cmd, h, offset, value, mask);
191 }
192
193 static int pmf_parser_read_reg16(struct pmf_cmd *cmd, struct pmf_handlers *h)
194 {
195 u32 offset = pmf_next32(cmd);
196
197 LOG_PARSE("pmf: read_reg16(offset: %08x)\n", offset);
198
199 PMF_PARSE_CALL(read_reg16, cmd, h, offset);
200 }
201
202
203 static int pmf_parser_write_reg8(struct pmf_cmd *cmd, struct pmf_handlers *h)
204 {
205 u32 offset = pmf_next32(cmd);
206 u8 value = (u16)pmf_next32(cmd);
207 u8 mask = (u16)pmf_next32(cmd);
208
209 LOG_PARSE("pmf: write_reg8(offset: %08x, value: %02x, mask: %02x)\n",
210 offset, value, mask);
211
212 PMF_PARSE_CALL(write_reg8, cmd, h, offset, value, mask);
213 }
214
215 static int pmf_parser_read_reg8(struct pmf_cmd *cmd, struct pmf_handlers *h)
216 {
217 u32 offset = pmf_next32(cmd);
218
219 LOG_PARSE("pmf: read_reg8(offset: %08x)\n", offset);
220
221 PMF_PARSE_CALL(read_reg8, cmd, h, offset);
222 }
223
224 static int pmf_parser_delay(struct pmf_cmd *cmd, struct pmf_handlers *h)
225 {
226 u32 duration = pmf_next32(cmd);
227
228 LOG_PARSE("pmf: delay(duration: %d us)\n", duration);
229
230 PMF_PARSE_CALL(delay, cmd, h, duration);
231 }
232
233 static int pmf_parser_wait_reg32(struct pmf_cmd *cmd, struct pmf_handlers *h)
234 {
235 u32 offset = pmf_next32(cmd);
236 u32 value = pmf_next32(cmd);
237 u32 mask = pmf_next32(cmd);
238
239 LOG_PARSE("pmf: wait_reg32(offset: %08x, comp_value: %08x,mask: %08x)\n",
240 offset, value, mask);
241
242 PMF_PARSE_CALL(wait_reg32, cmd, h, offset, value, mask);
243 }
244
245 static int pmf_parser_wait_reg16(struct pmf_cmd *cmd, struct pmf_handlers *h)
246 {
247 u32 offset = pmf_next32(cmd);
248 u16 value = (u16)pmf_next32(cmd);
249 u16 mask = (u16)pmf_next32(cmd);
250
251 LOG_PARSE("pmf: wait_reg16(offset: %08x, comp_value: %04x,mask: %04x)\n",
252 offset, value, mask);
253
254 PMF_PARSE_CALL(wait_reg16, cmd, h, offset, value, mask);
255 }
256
257 static int pmf_parser_wait_reg8(struct pmf_cmd *cmd, struct pmf_handlers *h)
258 {
259 u32 offset = pmf_next32(cmd);
260 u8 value = (u8)pmf_next32(cmd);
261 u8 mask = (u8)pmf_next32(cmd);
262
263 LOG_PARSE("pmf: wait_reg8(offset: %08x, comp_value: %02x,mask: %02x)\n",
264 offset, value, mask);
265
266 PMF_PARSE_CALL(wait_reg8, cmd, h, offset, value, mask);
267 }
268
269 static int pmf_parser_read_i2c(struct pmf_cmd *cmd, struct pmf_handlers *h)
270 {
271 u32 bytes = pmf_next32(cmd);
272
273 LOG_PARSE("pmf: read_i2c(bytes: %ud)\n", bytes);
274
275 PMF_PARSE_CALL(read_i2c, cmd, h, bytes);
276 }
277
278 static int pmf_parser_write_i2c(struct pmf_cmd *cmd, struct pmf_handlers *h)
279 {
280 u32 bytes = pmf_next32(cmd);
281 const void *blob = pmf_next_blob(cmd, bytes);
282
283 LOG_PARSE("pmf: write_i2c(bytes: %ud) ...\n", bytes);
284 LOG_BLOB("pmf: data: \n", blob, bytes);
285
286 PMF_PARSE_CALL(write_i2c, cmd, h, bytes, blob);
287 }
288
289
290 static int pmf_parser_rmw_i2c(struct pmf_cmd *cmd, struct pmf_handlers *h)
291 {
292 u32 maskbytes = pmf_next32(cmd);
293 u32 valuesbytes = pmf_next32(cmd);
294 u32 totalbytes = pmf_next32(cmd);
295 const void *maskblob = pmf_next_blob(cmd, maskbytes);
296 const void *valuesblob = pmf_next_blob(cmd, valuesbytes);
297
298 LOG_PARSE("pmf: rmw_i2c(maskbytes: %ud, valuebytes: %ud, "
299 "totalbytes: %d) ...\n",
300 maskbytes, valuesbytes, totalbytes);
301 LOG_BLOB("pmf: mask data: \n", maskblob, maskbytes);
302 LOG_BLOB("pmf: values data: \n", valuesblob, valuesbytes);
303
304 PMF_PARSE_CALL(rmw_i2c, cmd, h, maskbytes, valuesbytes, totalbytes,
305 maskblob, valuesblob);
306 }
307
308 static int pmf_parser_read_cfg(struct pmf_cmd *cmd, struct pmf_handlers *h)
309 {
310 u32 offset = pmf_next32(cmd);
311 u32 bytes = pmf_next32(cmd);
312
313 LOG_PARSE("pmf: read_cfg(offset: %x, bytes: %ud)\n", offset, bytes);
314
315 PMF_PARSE_CALL(read_cfg, cmd, h, offset, bytes);
316 }
317
318
319 static int pmf_parser_write_cfg(struct pmf_cmd *cmd, struct pmf_handlers *h)
320 {
321 u32 offset = pmf_next32(cmd);
322 u32 bytes = pmf_next32(cmd);
323 const void *blob = pmf_next_blob(cmd, bytes);
324
325 LOG_PARSE("pmf: write_cfg(offset: %x, bytes: %ud)\n", offset, bytes);
326 LOG_BLOB("pmf: data: \n", blob, bytes);
327
328 PMF_PARSE_CALL(write_cfg, cmd, h, offset, bytes, blob);
329 }
330
331 static int pmf_parser_rmw_cfg(struct pmf_cmd *cmd, struct pmf_handlers *h)
332 {
333 u32 offset = pmf_next32(cmd);
334 u32 maskbytes = pmf_next32(cmd);
335 u32 valuesbytes = pmf_next32(cmd);
336 u32 totalbytes = pmf_next32(cmd);
337 const void *maskblob = pmf_next_blob(cmd, maskbytes);
338 const void *valuesblob = pmf_next_blob(cmd, valuesbytes);
339
340 LOG_PARSE("pmf: rmw_cfg(maskbytes: %ud, valuebytes: %ud,"
341 " totalbytes: %d) ...\n",
342 maskbytes, valuesbytes, totalbytes);
343 LOG_BLOB("pmf: mask data: \n", maskblob, maskbytes);
344 LOG_BLOB("pmf: values data: \n", valuesblob, valuesbytes);
345
346 PMF_PARSE_CALL(rmw_cfg, cmd, h, offset, maskbytes, valuesbytes,
347 totalbytes, maskblob, valuesblob);
348 }
349
350
351 static int pmf_parser_read_i2c_sub(struct pmf_cmd *cmd, struct pmf_handlers *h)
352 {
353 u8 subaddr = (u8)pmf_next32(cmd);
354 u32 bytes = pmf_next32(cmd);
355
356 LOG_PARSE("pmf: read_i2c_sub(subaddr: %x, bytes: %ud)\n",
357 subaddr, bytes);
358
359 PMF_PARSE_CALL(read_i2c_sub, cmd, h, subaddr, bytes);
360 }
361
362 static int pmf_parser_write_i2c_sub(struct pmf_cmd *cmd, struct pmf_handlers *h)
363 {
364 u8 subaddr = (u8)pmf_next32(cmd);
365 u32 bytes = pmf_next32(cmd);
366 const void *blob = pmf_next_blob(cmd, bytes);
367
368 LOG_PARSE("pmf: write_i2c_sub(subaddr: %x, bytes: %ud) ...\n",
369 subaddr, bytes);
370 LOG_BLOB("pmf: data: \n", blob, bytes);
371
372 PMF_PARSE_CALL(write_i2c_sub, cmd, h, subaddr, bytes, blob);
373 }
374
375 static int pmf_parser_set_i2c_mode(struct pmf_cmd *cmd, struct pmf_handlers *h)
376 {
377 u32 mode = pmf_next32(cmd);
378
379 LOG_PARSE("pmf: set_i2c_mode(mode: %d)\n", mode);
380
381 PMF_PARSE_CALL(set_i2c_mode, cmd, h, mode);
382 }
383
384
385 static int pmf_parser_rmw_i2c_sub(struct pmf_cmd *cmd, struct pmf_handlers *h)
386 {
387 u8 subaddr = (u8)pmf_next32(cmd);
388 u32 maskbytes = pmf_next32(cmd);
389 u32 valuesbytes = pmf_next32(cmd);
390 u32 totalbytes = pmf_next32(cmd);
391 const void *maskblob = pmf_next_blob(cmd, maskbytes);
392 const void *valuesblob = pmf_next_blob(cmd, valuesbytes);
393
394 LOG_PARSE("pmf: rmw_i2c_sub(subaddr: %x, maskbytes: %ud, valuebytes: %ud"
395 ", totalbytes: %d) ...\n",
396 subaddr, maskbytes, valuesbytes, totalbytes);
397 LOG_BLOB("pmf: mask data: \n", maskblob, maskbytes);
398 LOG_BLOB("pmf: values data: \n", valuesblob, valuesbytes);
399
400 PMF_PARSE_CALL(rmw_i2c_sub, cmd, h, subaddr, maskbytes, valuesbytes,
401 totalbytes, maskblob, valuesblob);
402 }
403
404 static int pmf_parser_read_reg32_msrx(struct pmf_cmd *cmd,
405 struct pmf_handlers *h)
406 {
407 u32 offset = pmf_next32(cmd);
408 u32 mask = pmf_next32(cmd);
409 u32 shift = pmf_next32(cmd);
410 u32 xor = pmf_next32(cmd);
411
412 LOG_PARSE("pmf: read_reg32_msrx(offset: %x, mask: %x, shift: %x,"
413 " xor: %x\n", offset, mask, shift, xor);
414
415 PMF_PARSE_CALL(read_reg32_msrx, cmd, h, offset, mask, shift, xor);
416 }
417
418 static int pmf_parser_read_reg16_msrx(struct pmf_cmd *cmd,
419 struct pmf_handlers *h)
420 {
421 u32 offset = pmf_next32(cmd);
422 u32 mask = pmf_next32(cmd);
423 u32 shift = pmf_next32(cmd);
424 u32 xor = pmf_next32(cmd);
425
426 LOG_PARSE("pmf: read_reg16_msrx(offset: %x, mask: %x, shift: %x,"
427 " xor: %x\n", offset, mask, shift, xor);
428
429 PMF_PARSE_CALL(read_reg16_msrx, cmd, h, offset, mask, shift, xor);
430 }
431 static int pmf_parser_read_reg8_msrx(struct pmf_cmd *cmd,
432 struct pmf_handlers *h)
433 {
434 u32 offset = pmf_next32(cmd);
435 u32 mask = pmf_next32(cmd);
436 u32 shift = pmf_next32(cmd);
437 u32 xor = pmf_next32(cmd);
438
439 LOG_PARSE("pmf: read_reg8_msrx(offset: %x, mask: %x, shift: %x,"
440 " xor: %x\n", offset, mask, shift, xor);
441
442 PMF_PARSE_CALL(read_reg8_msrx, cmd, h, offset, mask, shift, xor);
443 }
444
445 static int pmf_parser_write_reg32_slm(struct pmf_cmd *cmd,
446 struct pmf_handlers *h)
447 {
448 u32 offset = pmf_next32(cmd);
449 u32 shift = pmf_next32(cmd);
450 u32 mask = pmf_next32(cmd);
451
452 LOG_PARSE("pmf: write_reg32_slm(offset: %x, shift: %x, mask: %x\n",
453 offset, shift, mask);
454
455 PMF_PARSE_CALL(write_reg32_slm, cmd, h, offset, shift, mask);
456 }
457
458 static int pmf_parser_write_reg16_slm(struct pmf_cmd *cmd,
459 struct pmf_handlers *h)
460 {
461 u32 offset = pmf_next32(cmd);
462 u32 shift = pmf_next32(cmd);
463 u32 mask = pmf_next32(cmd);
464
465 LOG_PARSE("pmf: write_reg16_slm(offset: %x, shift: %x, mask: %x\n",
466 offset, shift, mask);
467
468 PMF_PARSE_CALL(write_reg16_slm, cmd, h, offset, shift, mask);
469 }
470
471 static int pmf_parser_write_reg8_slm(struct pmf_cmd *cmd,
472 struct pmf_handlers *h)
473 {
474 u32 offset = pmf_next32(cmd);
475 u32 shift = pmf_next32(cmd);
476 u32 mask = pmf_next32(cmd);
477
478 LOG_PARSE("pmf: write_reg8_slm(offset: %x, shift: %x, mask: %x\n",
479 offset, shift, mask);
480
481 PMF_PARSE_CALL(write_reg8_slm, cmd, h, offset, shift, mask);
482 }
483
484 static int pmf_parser_mask_and_compare(struct pmf_cmd *cmd,
485 struct pmf_handlers *h)
486 {
487 u32 bytes = pmf_next32(cmd);
488 const void *maskblob = pmf_next_blob(cmd, bytes);
489 const void *valuesblob = pmf_next_blob(cmd, bytes);
490
491 LOG_PARSE("pmf: mask_and_compare(length: %ud ...\n", bytes);
492 LOG_BLOB("pmf: mask data: \n", maskblob, bytes);
493 LOG_BLOB("pmf: values data: \n", valuesblob, bytes);
494
495 PMF_PARSE_CALL(mask_and_compare, cmd, h,
496 bytes, maskblob, valuesblob);
497 }
498
499
500 typedef int (*pmf_cmd_parser_t)(struct pmf_cmd *cmd, struct pmf_handlers *h);
501
502 static pmf_cmd_parser_t pmf_parsers[PMF_CMD_COUNT] =
503 {
504 NULL,
505 pmf_parser_write_gpio,
506 pmf_parser_read_gpio,
507 pmf_parser_write_reg32,
508 pmf_parser_read_reg32,
509 pmf_parser_write_reg16,
510 pmf_parser_read_reg16,
511 pmf_parser_write_reg8,
512 pmf_parser_read_reg8,
513 pmf_parser_delay,
514 pmf_parser_wait_reg32,
515 pmf_parser_wait_reg16,
516 pmf_parser_wait_reg8,
517 pmf_parser_read_i2c,
518 pmf_parser_write_i2c,
519 pmf_parser_rmw_i2c,
520 NULL, /* Bogus command */
521 NULL, /* Shift bytes right: NYI */
522 NULL, /* Shift bytes left: NYI */
523 pmf_parser_read_cfg,
524 pmf_parser_write_cfg,
525 pmf_parser_rmw_cfg,
526 pmf_parser_read_i2c_sub,
527 pmf_parser_write_i2c_sub,
528 pmf_parser_set_i2c_mode,
529 pmf_parser_rmw_i2c_sub,
530 pmf_parser_read_reg32_msrx,
531 pmf_parser_read_reg16_msrx,
532 pmf_parser_read_reg8_msrx,
533 pmf_parser_write_reg32_slm,
534 pmf_parser_write_reg16_slm,
535 pmf_parser_write_reg8_slm,
536 pmf_parser_mask_and_compare,
537 };
538
539 struct pmf_device {
540 struct list_head link;
541 struct device_node *node;
542 struct pmf_handlers *handlers;
543 struct list_head functions;
544 struct kref ref;
545 };
546
547 static LIST_HEAD(pmf_devices);
548 static DEFINE_SPINLOCK(pmf_lock);
549 static DEFINE_MUTEX(pmf_irq_mutex);
550
551 static void pmf_release_device(struct kref *kref)
552 {
553 struct pmf_device *dev = container_of(kref, struct pmf_device, ref);
554 kfree(dev);
555 }
556
557 static inline void pmf_put_device(struct pmf_device *dev)
558 {
559 kref_put(&dev->ref, pmf_release_device);
560 }
561
562 static inline struct pmf_device *pmf_get_device(struct pmf_device *dev)
563 {
564 kref_get(&dev->ref);
565 return dev;
566 }
567
568 static inline struct pmf_device *pmf_find_device(struct device_node *np)
569 {
570 struct pmf_device *dev;
571
572 list_for_each_entry(dev, &pmf_devices, link) {
573 if (dev->node == np)
574 return pmf_get_device(dev);
575 }
576 return NULL;
577 }
578
579 static int pmf_parse_one(struct pmf_function *func,
580 struct pmf_handlers *handlers,
581 void *instdata, struct pmf_args *args)
582 {
583 struct pmf_cmd cmd;
584 u32 ccode;
585 int count, rc;
586
587 cmd.cmdptr = func->data;
588 cmd.cmdend = func->data + func->length;
589 cmd.func = func;
590 cmd.instdata = instdata;
591 cmd.args = args;
592 cmd.error = 0;
593
594 LOG_PARSE("pmf: func %s, %d bytes, %s...\n",
595 func->name, func->length,
596 handlers ? "executing" : "parsing");
597
598 /* One subcommand to parse for now */
599 count = 1;
600
601 while(count-- && cmd.cmdptr < cmd.cmdend) {
602 /* Get opcode */
603 ccode = pmf_next32(&cmd);
604 /* Check if we are hitting a command list, fetch new count */
605 if (ccode == 0) {
606 count = pmf_next32(&cmd) - 1;
607 ccode = pmf_next32(&cmd);
608 }
609 if (cmd.error) {
610 LOG_ERROR("pmf: parse error, not enough data\n");
611 return -ENXIO;
612 }
613 if (ccode >= PMF_CMD_COUNT) {
614 LOG_ERROR("pmf: command code %d unknown !\n", ccode);
615 return -ENXIO;
616 }
617 if (pmf_parsers[ccode] == NULL) {
618 LOG_ERROR("pmf: no parser for command %d !\n", ccode);
619 return -ENXIO;
620 }
621 rc = pmf_parsers[ccode](&cmd, handlers);
622 if (rc != 0) {
623 LOG_ERROR("pmf: parser for command %d returned"
624 " error %d\n", ccode, rc);
625 return rc;
626 }
627 }
628
629 /* We are doing an initial parse pass, we need to adjust the size */
630 if (handlers == NULL)
631 func->length = cmd.cmdptr - func->data;
632
633 return 0;
634 }
635
636 static int pmf_add_function_prop(struct pmf_device *dev, void *driverdata,
637 const char *name, u32 *data,
638 unsigned int length)
639 {
640 int count = 0;
641 struct pmf_function *func = NULL;
642
643 DBG("pmf: Adding functions for platform-do-%s\n", name);
644
645 while (length >= 12) {
646 /* Allocate a structure */
647 func = kzalloc(sizeof(struct pmf_function), GFP_KERNEL);
648 if (func == NULL)
649 goto bail;
650 kref_init(&func->ref);
651 INIT_LIST_HEAD(&func->irq_clients);
652 func->node = dev->node;
653 func->driver_data = driverdata;
654 func->name = name;
655 func->phandle = data[0];
656 func->flags = data[1];
657 data += 2;
658 length -= 8;
659 func->data = data;
660 func->length = length;
661 func->dev = dev;
662 DBG("pmf: idx %d: flags=%08x, phandle=%08x "
663 " %d bytes remaining, parsing...\n",
664 count+1, func->flags, func->phandle, length);
665 if (pmf_parse_one(func, NULL, NULL, NULL)) {
666 kfree(func);
667 goto bail;
668 }
669 length -= func->length;
670 data = (u32 *)(((u8 *)data) + func->length);
671 list_add(&func->link, &dev->functions);
672 pmf_get_device(dev);
673 count++;
674 }
675 bail:
676 DBG("pmf: Added %d functions\n", count);
677
678 return count;
679 }
680
681 static int pmf_add_functions(struct pmf_device *dev, void *driverdata)
682 {
683 struct property *pp;
684 #define PP_PREFIX "platform-do-"
685 const int plen = strlen(PP_PREFIX);
686 int count = 0;
687
688 for (pp = dev->node->properties; pp != 0; pp = pp->next) {
689 char *name;
690 if (strncmp(pp->name, PP_PREFIX, plen) != 0)
691 continue;
692 name = pp->name + plen;
693 if (strlen(name) && pp->length >= 12)
694 count += pmf_add_function_prop(dev, driverdata, name,
695 (u32 *)pp->value,
696 pp->length);
697 }
698 return count;
699 }
700
701
702 int pmf_register_driver(struct device_node *np,
703 struct pmf_handlers *handlers,
704 void *driverdata)
705 {
706 struct pmf_device *dev;
707 unsigned long flags;
708 int rc = 0;
709
710 if (handlers == NULL)
711 return -EINVAL;
712
713 DBG("pmf: registering driver for node %s\n", np->full_name);
714
715 spin_lock_irqsave(&pmf_lock, flags);
716 dev = pmf_find_device(np);
717 spin_unlock_irqrestore(&pmf_lock, flags);
718 if (dev != NULL) {
719 DBG("pmf: already there !\n");
720 pmf_put_device(dev);
721 return -EBUSY;
722 }
723
724 dev = kzalloc(sizeof(struct pmf_device), GFP_KERNEL);
725 if (dev == NULL) {
726 DBG("pmf: no memory !\n");
727 return -ENOMEM;
728 }
729 kref_init(&dev->ref);
730 dev->node = of_node_get(np);
731 dev->handlers = handlers;
732 INIT_LIST_HEAD(&dev->functions);
733
734 rc = pmf_add_functions(dev, driverdata);
735 if (rc == 0) {
736 DBG("pmf: no functions, disposing.. \n");
737 of_node_put(np);
738 kfree(dev);
739 return -ENODEV;
740 }
741
742 spin_lock_irqsave(&pmf_lock, flags);
743 list_add(&dev->link, &pmf_devices);
744 spin_unlock_irqrestore(&pmf_lock, flags);
745
746 return 0;
747 }
748 EXPORT_SYMBOL_GPL(pmf_register_driver);
749
750 struct pmf_function *pmf_get_function(struct pmf_function *func)
751 {
752 if (!try_module_get(func->dev->handlers->owner))
753 return NULL;
754 kref_get(&func->ref);
755 return func;
756 }
757 EXPORT_SYMBOL_GPL(pmf_get_function);
758
759 static void pmf_release_function(struct kref *kref)
760 {
761 struct pmf_function *func =
762 container_of(kref, struct pmf_function, ref);
763 pmf_put_device(func->dev);
764 kfree(func);
765 }
766
767 static inline void __pmf_put_function(struct pmf_function *func)
768 {
769 kref_put(&func->ref, pmf_release_function);
770 }
771
772 void pmf_put_function(struct pmf_function *func)
773 {
774 if (func == NULL)
775 return;
776 module_put(func->dev->handlers->owner);
777 __pmf_put_function(func);
778 }
779 EXPORT_SYMBOL_GPL(pmf_put_function);
780
781 void pmf_unregister_driver(struct device_node *np)
782 {
783 struct pmf_device *dev;
784 unsigned long flags;
785
786 DBG("pmf: unregistering driver for node %s\n", np->full_name);
787
788 spin_lock_irqsave(&pmf_lock, flags);
789 dev = pmf_find_device(np);
790 if (dev == NULL) {
791 DBG("pmf: not such driver !\n");
792 spin_unlock_irqrestore(&pmf_lock, flags);
793 return;
794 }
795 list_del(&dev->link);
796
797 while(!list_empty(&dev->functions)) {
798 struct pmf_function *func =
799 list_entry(dev->functions.next, typeof(*func), link);
800 list_del(&func->link);
801 __pmf_put_function(func);
802 }
803
804 pmf_put_device(dev);
805 spin_unlock_irqrestore(&pmf_lock, flags);
806 }
807 EXPORT_SYMBOL_GPL(pmf_unregister_driver);
808
809 struct pmf_function *__pmf_find_function(struct device_node *target,
810 const char *name, u32 flags)
811 {
812 struct device_node *actor = of_node_get(target);
813 struct pmf_device *dev;
814 struct pmf_function *func, *result = NULL;
815 char fname[64];
816 const u32 *prop;
817 u32 ph;
818
819 /*
820 * Look for a "platform-*" function reference. If we can't find
821 * one, then we fallback to a direct call attempt
822 */
823 snprintf(fname, 63, "platform-%s", name);
824 prop = get_property(target, fname, NULL);
825 if (prop == NULL)
826 goto find_it;
827 ph = *prop;
828 if (ph == 0)
829 goto find_it;
830
831 /*
832 * Ok, now try to find the actor. If we can't find it, we fail,
833 * there is no point in falling back there
834 */
835 of_node_put(actor);
836 actor = of_find_node_by_phandle(ph);
837 if (actor == NULL)
838 return NULL;
839 find_it:
840 dev = pmf_find_device(actor);
841 if (dev == NULL)
842 return NULL;
843
844 list_for_each_entry(func, &dev->functions, link) {
845 if (name && strcmp(name, func->name))
846 continue;
847 if (func->phandle && target->node != func->phandle)
848 continue;
849 if ((func->flags & flags) == 0)
850 continue;
851 result = func;
852 break;
853 }
854 of_node_put(actor);
855 pmf_put_device(dev);
856 return result;
857 }
858
859
860 int pmf_register_irq_client(struct device_node *target,
861 const char *name,
862 struct pmf_irq_client *client)
863 {
864 struct pmf_function *func;
865 unsigned long flags;
866
867 spin_lock_irqsave(&pmf_lock, flags);
868 func = __pmf_find_function(target, name, PMF_FLAGS_INT_GEN);
869 if (func)
870 func = pmf_get_function(func);
871 spin_unlock_irqrestore(&pmf_lock, flags);
872 if (func == NULL)
873 return -ENODEV;
874
875 /* guard against manipulations of list */
876 mutex_lock(&pmf_irq_mutex);
877 if (list_empty(&func->irq_clients))
878 func->dev->handlers->irq_enable(func);
879
880 /* guard against pmf_do_irq while changing list */
881 spin_lock_irqsave(&pmf_lock, flags);
882 list_add(&client->link, &func->irq_clients);
883 spin_unlock_irqrestore(&pmf_lock, flags);
884
885 client->func = func;
886 mutex_unlock(&pmf_irq_mutex);
887
888 return 0;
889 }
890 EXPORT_SYMBOL_GPL(pmf_register_irq_client);
891
892 void pmf_unregister_irq_client(struct pmf_irq_client *client)
893 {
894 struct pmf_function *func = client->func;
895 unsigned long flags;
896
897 BUG_ON(func == NULL);
898
899 /* guard against manipulations of list */
900 mutex_lock(&pmf_irq_mutex);
901 client->func = NULL;
902
903 /* guard against pmf_do_irq while changing list */
904 spin_lock_irqsave(&pmf_lock, flags);
905 list_del(&client->link);
906 spin_unlock_irqrestore(&pmf_lock, flags);
907
908 if (list_empty(&func->irq_clients))
909 func->dev->handlers->irq_disable(func);
910 mutex_unlock(&pmf_irq_mutex);
911 pmf_put_function(func);
912 }
913 EXPORT_SYMBOL_GPL(pmf_unregister_irq_client);
914
915
916 void pmf_do_irq(struct pmf_function *func)
917 {
918 unsigned long flags;
919 struct pmf_irq_client *client;
920
921 /* For now, using a spinlock over the whole function. Can be made
922 * to drop the lock using 2 lists if necessary
923 */
924 spin_lock_irqsave(&pmf_lock, flags);
925 list_for_each_entry(client, &func->irq_clients, link) {
926 if (!try_module_get(client->owner))
927 continue;
928 client->handler(client->data);
929 module_put(client->owner);
930 }
931 spin_unlock_irqrestore(&pmf_lock, flags);
932 }
933 EXPORT_SYMBOL_GPL(pmf_do_irq);
934
935
936 int pmf_call_one(struct pmf_function *func, struct pmf_args *args)
937 {
938 struct pmf_device *dev = func->dev;
939 void *instdata = NULL;
940 int rc = 0;
941
942 DBG(" ** pmf_call_one(%s/%s) **\n", dev->node->full_name, func->name);
943
944 if (dev->handlers->begin)
945 instdata = dev->handlers->begin(func, args);
946 rc = pmf_parse_one(func, dev->handlers, instdata, args);
947 if (dev->handlers->end)
948 dev->handlers->end(func, instdata);
949
950 return rc;
951 }
952 EXPORT_SYMBOL_GPL(pmf_call_one);
953
954 int pmf_do_functions(struct device_node *np, const char *name,
955 u32 phandle, u32 fflags, struct pmf_args *args)
956 {
957 struct pmf_device *dev;
958 struct pmf_function *func, *tmp;
959 unsigned long flags;
960 int rc = -ENODEV;
961
962 spin_lock_irqsave(&pmf_lock, flags);
963
964 dev = pmf_find_device(np);
965 if (dev == NULL) {
966 spin_unlock_irqrestore(&pmf_lock, flags);
967 return -ENODEV;
968 }
969 list_for_each_entry_safe(func, tmp, &dev->functions, link) {
970 if (name && strcmp(name, func->name))
971 continue;
972 if (phandle && func->phandle && phandle != func->phandle)
973 continue;
974 if ((func->flags & fflags) == 0)
975 continue;
976 if (pmf_get_function(func) == NULL)
977 continue;
978 spin_unlock_irqrestore(&pmf_lock, flags);
979 rc = pmf_call_one(func, args);
980 pmf_put_function(func);
981 spin_lock_irqsave(&pmf_lock, flags);
982 }
983 pmf_put_device(dev);
984 spin_unlock_irqrestore(&pmf_lock, flags);
985
986 return rc;
987 }
988 EXPORT_SYMBOL_GPL(pmf_do_functions);
989
990
991 struct pmf_function *pmf_find_function(struct device_node *target,
992 const char *name)
993 {
994 struct pmf_function *func;
995 unsigned long flags;
996
997 spin_lock_irqsave(&pmf_lock, flags);
998 func = __pmf_find_function(target, name, PMF_FLAGS_ON_DEMAND);
999 if (func)
1000 func = pmf_get_function(func);
1001 spin_unlock_irqrestore(&pmf_lock, flags);
1002 return func;
1003 }
1004 EXPORT_SYMBOL_GPL(pmf_find_function);
1005
1006 int pmf_call_function(struct device_node *target, const char *name,
1007 struct pmf_args *args)
1008 {
1009 struct pmf_function *func = pmf_find_function(target, name);
1010 int rc;
1011
1012 if (func == NULL)
1013 return -ENODEV;
1014
1015 rc = pmf_call_one(func, args);
1016 pmf_put_function(func);
1017 return rc;
1018 }
1019 EXPORT_SYMBOL_GPL(pmf_call_function);
1020
Support for the Chinese Samsung S3C2440 based development boards