From ad561caafaa02b2e1dfe25f6bae03806051992eb Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Tue, 22 Apr 2008 14:46:19 -0300 Subject: V4L/DVB (7423): dvb-pll: remove support for Philips TD1316 Signed-off-by: Michael Krufky Signed-off-by: Mauro Carvalho Chehab --- drivers/media/dvb/frontends/dvb-pll.c | 43 ----------------------------------- drivers/media/dvb/frontends/dvb-pll.h | 1 - 2 files changed, 44 deletions(-) diff --git a/drivers/media/dvb/frontends/dvb-pll.c b/drivers/media/dvb/frontends/dvb-pll.c index 7735e7484e78..b2491f106cef 100644 --- a/drivers/media/dvb/frontends/dvb-pll.c +++ b/drivers/media/dvb/frontends/dvb-pll.c @@ -374,48 +374,6 @@ static struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261 = { }, }; -/* - * Philips TD1316 Tuner. - */ -static void td1316_bw(struct dvb_frontend *fe, u8 *buf, - const struct dvb_frontend_parameters *params) -{ - u8 band; - - /* determine band */ - if (params->frequency < 161000000) - band = 1; - else if (params->frequency < 444000000) - band = 2; - else - band = 4; - - buf[3] |= band; - - /* setup PLL filter */ - if (params->u.ofdm.bandwidth == BANDWIDTH_8_MHZ) - buf[3] |= 1 << 3; -} - -static struct dvb_pll_desc dvb_pll_philips_td1316 = { - .name = "Philips TD1316", - .min = 87000000, - .max = 895000000, - .iffreq= 36166667, - .set = td1316_bw, - .count = 9, - .entries = { - { 93834000, 166667, 0xca, 0x60}, - { 123834000, 166667, 0xca, 0xa0}, - { 163834000, 166667, 0xca, 0xc0}, - { 253834000, 166667, 0xca, 0x60}, - { 383834000, 166667, 0xca, 0xa0}, - { 443834000, 166667, 0xca, 0xc0}, - { 583834000, 166667, 0xca, 0x60}, - { 793834000, 166667, 0xca, 0xa0}, - { 858834000, 166667, 0xca, 0xe0}, - }, -}; static void opera1_bw(struct dvb_frontend *fe, u8 *buf, @@ -462,7 +420,6 @@ static struct dvb_pll_desc *pll_list[] = { [DVB_PLL_TDHU2] = &dvb_pll_tdhu2, [DVB_PLL_SAMSUNG_TBMV] = &dvb_pll_samsung_tbmv, [DVB_PLL_PHILIPS_SD1878_TDA8261] = &dvb_pll_philips_sd1878_tda8261, - [DVB_PLL_PHILIPS_TD1316] = &dvb_pll_philips_td1316, [DVB_PLL_OPERA1] = &dvb_pll_opera1, }; diff --git a/drivers/media/dvb/frontends/dvb-pll.h b/drivers/media/dvb/frontends/dvb-pll.h index 48cd41fac1e1..8736ccb9954b 100644 --- a/drivers/media/dvb/frontends/dvb-pll.h +++ b/drivers/media/dvb/frontends/dvb-pll.h @@ -22,7 +22,6 @@ #define DVB_PLL_TDHU2 16 #define DVB_PLL_SAMSUNG_TBMV 17 #define DVB_PLL_PHILIPS_SD1878_TDA8261 18 -#define DVB_PLL_PHILIPS_TD1316 19 #define DVB_PLL_OPERA1 21 /** -- cgit v1.2.2 l'>wip-aedzl-final The LITMUS^RT kernel.Bjoern Brandenburg
aboutsummaryrefslogblamecommitdiffstats
path: root/crypto/algapi.c
blob: c91530021e9ce6744b1382950eb9fed3d258d119 (plain) (tree) 
cce9e06d100d












6bfd48096ff8

cce9e06d100d



4cc7720cd165

cce9e06d100d

7fed0bf271b3

cce9e06d100d




4cc7720cd165


492e2b63eb10

2825982d9d66




492e2b63eb10

2825982d9d66












cce9e06d100d

















4cc7720cd165

cce9e06d100d

cce9e06d100d











cce9e06d100d

4cc7720cd165



6bfd48096ff8












































4cc7720cd165


6bfd48096ff8








4cc7720cd165

2825982d9d66

cce9e06d100d

4cc7720cd165

cce9e06d100d

6bfd48096ff8





2825982d9d66


6bfd48096ff8






492e2b63eb10


2825982d9d66


6bfd48096ff8

2825982d9d66


6bfd48096ff8

2825982d9d66

6bfd48096ff8









cce9e06d100d



2825982d9d66


4cc7720cd165

2825982d9d66

cce9e06d100d

cce9e06d100d


4cc7720cd165

6bfd48096ff8











4cc7720cd165


6bfd48096ff8

4cc7720cd165







6bfd48096ff8

4cc7720cd165


6bfd48096ff8

4cc7720cd165


cce9e06d100d


6bfd48096ff8














cce9e06d100d


6bfd48096ff8


cce9e06d100d


6bfd48096ff8

cce9e06d100d









6bfd48096ff8

cce9e06d100d




4cc7720cd165













2825982d9d66

4cc7720cd165












6bfd48096ff8

4cc7720cd165








6bfd48096ff8


4cc7720cd165


2825982d9d66


4cc7720cd165






6bfd48096ff8

4cc7720cd165































6bfd48096ff8

4cc7720cd165













6bfd48096ff8

4cc7720cd165









6bfd48096ff8


4cc7720cd165





6bfd48096ff8






















































2825982d9d66












7fed0bf271b3




















































cce9e06d100d
















1
2
3
4
5
6
7
8
9
10
11
12

13

14
15
16

17

18

19

20
21
22
23

24
25

26

27
28
29
30

31

32
33
34
35
36
37
38
39
40
41
42
43

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

61

62

63
64
65
66
67
68
69
70
71
72
73

74

75
76
77

78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

122
123

124
125
126
127
128
129
130
131

132

133

134

135

136

137
138
139
140
141

142
143

144
145
146
147
148
149

150
151

152
153

154

155
156

157

158

159
160
161
162
163
164
165
166
167

168
169
170

171
172

173

174

175

176
177

178

179
180
181
182
183
184
185
186
187
188
189

190
191

192

193
194
195
196
197
198
199

200

201
202

203

204
205

206
207

208
209
210
211
212
213
214
215
216
217
218
219
220
221

222
223

224
225

226
227

228

229
230
231
232
233
234
235
236
237

238

239
240
241
242

243
244
245
246
247
248
249
250
251
252
253
254
255

256

257
258
259
260
261
262
263
264
265
266
267
268

269

270
271
272
273
274
275
276
277

278
279

280
281

282
283

284
285
286
287
288
289

290

291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321

322

323
324
325
326
327
328
329
330
331
332
333
334
335

336

337
338
339
340
341
342
343
344
345

346
347

348
349
350
351
352

353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406

407
408
409
410
411
412
413
414
415
416
417
418

419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470

471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486












                                                                             
                      


                         
                       
                         
                            



                         

                                       
                                                              



                                   
                                                    











                                                                   
















                                                                       
                                                   
 










                                                          
 


                                           











































                                                                          

                             







                                        
 
                                        
                                                            
                             
                                 




                                          

                                                                 





                                                                      

                                                                           

                                                 
 

                                                      
                                 
                 








                                                                       


                                                   

                                                    
                
 
        

                   
 










                                                          

                                               
                        






                                    
                                                

                                  
                                   

                   

                                       













                                                                            

                                                 

                        

                                    
                                            








                                                   
                                   



                                         












                                                             
                                                      











                                                             
                         







                                                   

                                                                

         

                                                        





                                                                
                                    






























                                                                             
                        












                                            
                                                       








                                                      

                                   




                                            





















































                                                                         











                                                                     



















































                                                                              















                                                   
/*
 * Cryptographic API for algorithms (i.e., low-level API).
 *
 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
 *
 * 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.
 *
 */

#include <linux/err.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/rtnetlink.h>
#include <linux/string.h>

#include "internal.h"

static LIST_HEAD(crypto_template_list);

void crypto_larval_error(const char *name, u32 type, u32 mask)
{
	struct crypto_alg *alg;

	down_read(&crypto_alg_sem);
	alg = __crypto_alg_lookup(name, type, mask);
	up_read(&crypto_alg_sem);

	if (alg) {
		if (crypto_is_larval(alg)) {
			struct crypto_larval *larval = (void *)alg;
			complete(&larval->completion);
		}
		crypto_mod_put(alg);
	}
}
EXPORT_SYMBOL_GPL(crypto_larval_error);

static inline int crypto_set_driver_name(struct crypto_alg *alg)
{
	static const char suffix[] = "-generic";
	char *driver_name = alg->cra_driver_name;
	int len;

	if (*driver_name)
		return 0;

	len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
	if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)
		return -ENAMETOOLONG;

	memcpy(driver_name + len, suffix, sizeof(suffix));
	return 0;
}

static int crypto_check_alg(struct crypto_alg *alg)
{
	if (alg->cra_alignmask & (alg->cra_alignmask + 1))
		return -EINVAL;

	if (alg->cra_alignmask & alg->cra_blocksize)
		return -EINVAL;

	if (alg->cra_blocksize > PAGE_SIZE / 8)
		return -EINVAL;

	if (alg->cra_priority < 0)
		return -EINVAL;

	return crypto_set_driver_name(alg);
}

static void crypto_destroy_instance(struct crypto_alg *alg)
{
	struct crypto_instance *inst = (void *)alg;
	struct crypto_template *tmpl = inst->tmpl;

	tmpl->free(inst);
	crypto_tmpl_put(tmpl);
}

static void crypto_remove_spawns(struct list_head *spawns,
				 struct list_head *list)
{
	struct crypto_spawn *spawn, *n;

	list_for_each_entry_safe(spawn, n, spawns, list) {
		struct crypto_instance *inst = spawn->inst;
		struct crypto_template *tmpl = inst->tmpl;

		list_del_init(&spawn->list);
		spawn->alg = NULL;

		if (crypto_is_dead(&inst->alg))
			continue;

		inst->alg.cra_flags |= CRYPTO_ALG_DEAD;
		if (!tmpl || !crypto_tmpl_get(tmpl))
			continue;

		crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg);
		list_move(&inst->alg.cra_list, list);
		hlist_del(&inst->list);
		inst->alg.cra_destroy = crypto_destroy_instance;

		if (!list_empty(&inst->alg.cra_users)) {
			if (&n->list == spawns)
				n = list_entry(inst->alg.cra_users.next,
					       typeof(*n), list);
			__list_splice(&inst->alg.cra_users, spawns->prev);
		}
	}
}

static int __crypto_register_alg(struct crypto_alg *alg,
				 struct list_head *list)
{
	struct crypto_alg *q;
	int ret = -EAGAIN;

	if (crypto_is_dead(alg))
		goto out;

	INIT_LIST_HEAD(&alg->cra_users);

	ret = -EEXIST;

	atomic_set(&alg->cra_refcnt, 1);
	list_for_each_entry(q, &crypto_alg_list, cra_list) {
		if (q == alg)
			goto out;

		if (crypto_is_moribund(q))
			continue;

		if (crypto_is_larval(q)) {
			struct crypto_larval *larval = (void *)q;

			if (strcmp(alg->cra_name, q->cra_name) &&
			    strcmp(alg->cra_driver_name, q->cra_name))
				continue;

			if (larval->adult)
				continue;
			if ((q->cra_flags ^ alg->cra_flags) & larval->mask)
				continue;
			if (!crypto_mod_get(alg))
				continue;

			larval->adult = alg;
			complete(&larval->completion);
			continue;
		}

		if (strcmp(alg->cra_name, q->cra_name))
			continue;

		if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&
		    q->cra_priority > alg->cra_priority)
			continue;

		crypto_remove_spawns(&q->cra_users, list);
	}
	
	list_add(&alg->cra_list, &crypto_alg_list);

	crypto_notify(CRYPTO_MSG_ALG_REGISTER, alg);
	ret = 0;

out:	
	return ret;
}

static void crypto_remove_final(struct list_head *list)
{
	struct crypto_alg *alg;
	struct crypto_alg *n;

	list_for_each_entry_safe(alg, n, list, cra_list) {
		list_del_init(&alg->cra_list);
		crypto_alg_put(alg);
	}
}

int crypto_register_alg(struct crypto_alg *alg)
{
	LIST_HEAD(list);
	int err;

	err = crypto_check_alg(alg);
	if (err)
		return err;

	down_write(&crypto_alg_sem);
	err = __crypto_register_alg(alg, &list);
	up_write(&crypto_alg_sem);

	crypto_remove_final(&list);
	return err;
}
EXPORT_SYMBOL_GPL(crypto_register_alg);

static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list)
{
	if (unlikely(list_empty(&alg->cra_list)))
		return -ENOENT;

	alg->cra_flags |= CRYPTO_ALG_DEAD;

	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg);
	list_del_init(&alg->cra_list);
	crypto_remove_spawns(&alg->cra_users, list);

	return 0;
}

int crypto_unregister_alg(struct crypto_alg *alg)
{
	int ret;
	LIST_HEAD(list);
	
	down_write(&crypto_alg_sem);
	ret = crypto_remove_alg(alg, &list);
	up_write(&crypto_alg_sem);

	if (ret)
		return ret;

	BUG_ON(atomic_read(&alg->cra_refcnt) != 1);
	if (alg->cra_destroy)
		alg->cra_destroy(alg);

	crypto_remove_final(&list);
	return 0;
}
EXPORT_SYMBOL_GPL(crypto_unregister_alg);

int crypto_register_template(struct crypto_template *tmpl)
{
	struct crypto_template *q;
	int err = -EEXIST;

	down_write(&crypto_alg_sem);

	list_for_each_entry(q, &crypto_template_list, list) {
		if (q == tmpl)
			goto out;
	}

	list_add(&tmpl->list, &crypto_template_list);
	crypto_notify(CRYPTO_MSG_TMPL_REGISTER, tmpl);
	err = 0;
out:
	up_write(&crypto_alg_sem);
	return err;
}
EXPORT_SYMBOL_GPL(crypto_register_template);

void crypto_unregister_template(struct crypto_template *tmpl)
{
	struct crypto_instance *inst;
	struct hlist_node *p, *n;
	struct hlist_head *list;
	LIST_HEAD(users);

	down_write(&crypto_alg_sem);

	BUG_ON(list_empty(&tmpl->list));
	list_del_init(&tmpl->list);

	list = &tmpl->instances;
	hlist_for_each_entry(inst, p, list, list) {
		int err = crypto_remove_alg(&inst->alg, &users);
		BUG_ON(err);
	}

	crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl);

	up_write(&crypto_alg_sem);

	hlist_for_each_entry_safe(inst, p, n, list, list) {
		BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1);
		tmpl->free(inst);
	}
	crypto_remove_final(&users);
}
EXPORT_SYMBOL_GPL(crypto_unregister_template);

static struct crypto_template *__crypto_lookup_template(const char *name)
{
	struct crypto_template *q, *tmpl = NULL;

	down_read(&crypto_alg_sem);
	list_for_each_entry(q, &crypto_template_list, list) {
		if (strcmp(q->name, name))
			continue;
		if (unlikely(!crypto_tmpl_get(q)))
			continue;

		tmpl = q;
		break;
	}
	up_read(&crypto_alg_sem);

	return tmpl;
}

struct crypto_template *crypto_lookup_template(const char *name)
{
	return try_then_request_module(__crypto_lookup_template(name), name);
}
EXPORT_SYMBOL_GPL(crypto_lookup_template);

int crypto_register_instance(struct crypto_template *tmpl,
			     struct crypto_instance *inst)
{
	LIST_HEAD(list);
	int err = -EINVAL;

	if (inst->alg.cra_destroy)
		goto err;

	err = crypto_check_alg(&inst->alg);
	if (err)
		goto err;

	inst->alg.cra_module = tmpl->module;